]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Mini doc update for wxConvFileName.
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304
2305 SWIGINTERNSHORT unsigned long
2306 SWIG_As_unsigned_SS_long(PyObject* obj)
2307 {
2308 unsigned long v;
2309 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2310 /*
2311 this is needed to make valgrind/purify happier.
2312 */
2313 memset((void*)&v, 0, sizeof(unsigned long));
2314 }
2315 return v;
2316 }
2317
2318
2319 SWIGINTERNSHORT int
2320 SWIG_Check_unsigned_SS_long(PyObject* obj)
2321 {
2322 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2323 }
2324
2325 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2326 wxImageHistogramEntry e = (*self)[key];
2327 return e.value;
2328 }
2329 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2330 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2331 wxImageHistogramEntry e = (*self)[key];
2332 return e.value;
2333 }
2334 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2335 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2336 colour.Green(),
2337 colour.Blue());
2338 wxImageHistogramEntry e = (*self)[key];
2339 return e.value;
2340 }
2341 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2342 if (width > 0 && height > 0)
2343 return new wxImage(width, height, clear);
2344 else
2345 return new wxImage;
2346 }
2347 static wxImage *new_wxImage(wxBitmap const &bitmap){
2348 return new wxImage(bitmap.ConvertToImage());
2349 }
2350 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2351 // Copy the source data so the wxImage can clean it up later
2352 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2353 if (copy == NULL) {
2354 PyErr_NoMemory();
2355 return NULL;
2356 }
2357 memcpy(copy, data, width*height*3);
2358 return new wxImage(width, height, copy, false);
2359 }
2360 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2361 // Copy the source data so the wxImage can clean it up later
2362 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2363 if (dcopy == NULL) {
2364 PyErr_NoMemory();
2365 return NULL;
2366 }
2367 memcpy(dcopy, data, width*height*3);
2368 unsigned char* acopy = (unsigned char*)malloc(width*height);
2369 if (acopy == NULL) {
2370 PyErr_NoMemory();
2371 return NULL;
2372 }
2373 memcpy(acopy, alpha, width*height);
2374
2375 return new wxImage(width, height, dcopy, acopy, false);
2376 }
2377 static wxSize wxImage_GetSize(wxImage *self){
2378 wxSize size(self->GetWidth(), self->GetHeight());
2379 return size;
2380 }
2381 static PyObject *wxImage_GetData(wxImage *self){
2382 unsigned char* data = self->GetData();
2383 int len = self->GetWidth() * self->GetHeight() * 3;
2384 PyObject* rv;
2385 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2386 return rv;
2387 }
2388 static void wxImage_SetData(wxImage *self,PyObject *data){
2389 unsigned char* dataPtr;
2390
2391 if (! PyString_Check(data)) {
2392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2393 "Expected string object"));
2394 return /* NULL */ ;
2395 }
2396
2397 size_t len = self->GetWidth() * self->GetHeight() * 3;
2398 dataPtr = (unsigned char*) malloc(len);
2399 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2400 self->SetData(dataPtr);
2401 // wxImage takes ownership of dataPtr...
2402 }
2403 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2404 unsigned char* data = self->GetData();
2405 int len = self->GetWidth() * self->GetHeight() * 3;
2406 PyObject* rv;
2407 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2408 return rv;
2409 }
2410 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2411 unsigned char* buffer;
2412 int size;
2413
2414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2415 if (!PyArg_Parse(data, "t#", &buffer, &size))
2416 goto done;
2417
2418 if (size != self->GetWidth() * self->GetHeight() * 3) {
2419 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2420 goto done;
2421 }
2422 self->SetData(buffer);
2423 done:
2424 wxPyEndBlockThreads(blocked);
2425 }
2426 static PyObject *wxImage_GetAlphaData(wxImage *self){
2427 unsigned char* data = self->GetAlpha();
2428 if (! data) {
2429 RETURN_NONE();
2430 } else {
2431 int len = self->GetWidth() * self->GetHeight();
2432 PyObject* rv;
2433 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2434 return rv;
2435 }
2436 }
2437 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2438 unsigned char* dataPtr;
2439
2440 if (! PyString_Check(data)) {
2441 PyErr_SetString(PyExc_TypeError, "Expected string object");
2442 return /* NULL */ ;
2443 }
2444
2445 size_t len = self->GetWidth() * self->GetHeight();
2446 dataPtr = (unsigned char*) malloc(len);
2447 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2448 self->SetAlpha(dataPtr);
2449 // wxImage takes ownership of dataPtr...
2450 }
2451 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2452 unsigned char* data = self->GetAlpha();
2453 int len = self->GetWidth() * self->GetHeight();
2454 PyObject* rv;
2455 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2456 return rv;
2457 }
2458 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2459 unsigned char* buffer;
2460 int size;
2461
2462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2463 if (!PyArg_Parse(data, "t#", &buffer, &size))
2464 goto done;
2465
2466 if (size != self->GetWidth() * self->GetHeight()) {
2467 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2468 goto done;
2469 }
2470 self->SetAlpha(buffer);
2471 done:
2472 wxPyEndBlockThreads(blocked);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2772
2773 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2774
2775 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2776 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2777 wxMenuItemList& list = self->GetMenuItems();
2778 return wxPy_ConvertList(&list);
2779 }
2780 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2781 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2782 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2783 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2784 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2785 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2786 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2787 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2788 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2789 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2790 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2791 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2792 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2793 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2794 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2795 static const wxString wxPyControlNameStr(wxControlNameStr);
2796 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Append(item, data);
2800 } else
2801 return self->Append(item);
2802 }
2803 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2804 if (clientData) {
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 return self->Insert(item, pos, data);
2807 } else
2808 return self->Insert(item, pos);
2809 }
2810 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2811 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2812 if (data) {
2813 Py_INCREF(data->m_obj);
2814 return data->m_obj;
2815 } else {
2816 Py_INCREF(Py_None);
2817 return Py_None;
2818 }
2819 }
2820 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2821 wxPyClientData* data = new wxPyClientData(clientData);
2822 self->SetClientObject(n, data);
2823 }
2824
2825
2826 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2827 wxPyUserData* data = NULL;
2828 if ( userData ) {
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2830 data = new wxPyUserData(userData);
2831 wxPyEndBlockThreads(blocked);
2832 }
2833 return new wxSizerItem(window, proportion, flag, border, data);
2834 }
2835 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2836 wxPyUserData* data = NULL;
2837 if ( userData ) {
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 data = new wxPyUserData(userData);
2840 wxPyEndBlockThreads(blocked);
2841 }
2842 return new wxSizerItem(width, height, proportion, flag, border, data);
2843 }
2844 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2845 wxPyUserData* data = NULL;
2846 if ( userData ) {
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2848 data = new wxPyUserData(userData);
2849 wxPyEndBlockThreads(blocked);
2850 }
2851 return new wxSizerItem(sizer, proportion, flag, border, data);
2852 }
2853
2854 #include <float.h>
2855 SWIGINTERN int
2856 SWIG_CheckDoubleInRange(double value, double min_value,
2857 double max_value, const char* errmsg)
2858 {
2859 if (value < min_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is less than %s minimum %g",
2863 value, errmsg, min_value);
2864 }
2865 return 0;
2866 } else if (value > max_value) {
2867 if (errmsg) {
2868 PyErr_Format(PyExc_OverflowError,
2869 "value %g is greater than %s maximum %g",
2870 value, errmsg, max_value);
2871 }
2872 return 0;
2873 }
2874 return 1;
2875 }
2876
2877
2878 SWIGINTERN int
2879 SWIG_AsVal_float(PyObject *obj, float *val)
2880 {
2881 const char* errmsg = val ? "float" : (char*)0;
2882 double v;
2883 if (SWIG_AsVal_double(obj, &v)) {
2884 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2885 if (val) *val = (float)(v);
2886 return 1;
2887 } else {
2888 return 0;
2889 }
2890 } else {
2891 PyErr_Clear();
2892 }
2893 if (val) {
2894 SWIG_type_error(errmsg, obj);
2895 }
2896 return 0;
2897 }
2898
2899
2900 SWIGINTERNSHORT float
2901 SWIG_As_float(PyObject* obj)
2902 {
2903 float v;
2904 if (!SWIG_AsVal_float(obj, &v)) {
2905 /*
2906 this is needed to make valgrind/purify happier.
2907 */
2908 memset((void*)&v, 0, sizeof(float));
2909 }
2910 return v;
2911 }
2912
2913
2914 SWIGINTERNSHORT int
2915 SWIG_Check_float(PyObject* obj)
2916 {
2917 return SWIG_AsVal_float(obj, (float*)0);
2918 }
2919
2920
2921 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2922 #define SWIG_From_float PyFloat_FromDouble
2923 /*@@*/
2924
2925 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2926 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2927 if (data) {
2928 Py_INCREF(data->m_obj);
2929 return data->m_obj;
2930 } else {
2931 Py_INCREF(Py_None);
2932 return Py_None;
2933 }
2934 }
2935
2936 // Figure out the type of the sizer item
2937
2938 struct wxPySizerItemInfo {
2939 wxPySizerItemInfo()
2940 : window(NULL), sizer(NULL), gotSize(false),
2941 size(wxDefaultSize), gotPos(false), pos(-1)
2942 {}
2943
2944 wxWindow* window;
2945 wxSizer* sizer;
2946 bool gotSize;
2947 wxSize size;
2948 bool gotPos;
2949 int pos;
2950 };
2951
2952 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2953
2954 wxPySizerItemInfo info;
2955 wxSize size;
2956 wxSize* sizePtr = &size;
2957
2958 // Find out what the type of the item is
2959 // try wxWindow
2960 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2961 PyErr_Clear();
2962 info.window = NULL;
2963
2964 // try wxSizer
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2966 PyErr_Clear();
2967 info.sizer = NULL;
2968
2969 // try wxSize or (w,h)
2970 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2971 info.size = *sizePtr;
2972 info.gotSize = true;
2973 }
2974
2975 // or a single int
2976 if (checkIdx && PyInt_Check(item)) {
2977 info.pos = PyInt_AsLong(item);
2978 info.gotPos = true;
2979 }
2980 }
2981 }
2982
2983 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2984 // no expected type, figure out what kind of error message to generate
2985 if ( !checkSize && !checkIdx )
2986 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2987 else if ( checkSize && !checkIdx )
2988 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2989 else if ( !checkSize && checkIdx)
2990 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2991 else
2992 // can this one happen?
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2994 }
2995
2996 return info;
2997 }
2998
2999 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3000 if (!self->GetClientObject())
3001 self->SetClientObject(new wxPyOORClientData(_self));
3002 }
3003 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3004
3005 wxPyUserData* data = NULL;
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3007 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3008 if ( userData && (info.window || info.sizer || info.gotSize) )
3009 data = new wxPyUserData(userData);
3010 wxPyEndBlockThreads(blocked);
3011
3012 // Now call the real Add method if a valid item type was found
3013 if ( info.window )
3014 return self->Add(info.window, proportion, flag, border, data);
3015 else if ( info.sizer )
3016 return self->Add(info.sizer, proportion, flag, border, data);
3017 else if (info.gotSize)
3018 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3019 proportion, flag, border, data);
3020 else
3021 return NULL;
3022 }
3023 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3024
3025 wxPyUserData* data = NULL;
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3028 if ( userData && (info.window || info.sizer || info.gotSize) )
3029 data = new wxPyUserData(userData);
3030 wxPyEndBlockThreads(blocked);
3031
3032 // Now call the real Insert method if a valid item type was found
3033 if ( info.window )
3034 return self->Insert(before, info.window, proportion, flag, border, data);
3035 else if ( info.sizer )
3036 return self->Insert(before, info.sizer, proportion, flag, border, data);
3037 else if (info.gotSize)
3038 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3039 proportion, flag, border, data);
3040 else
3041 return NULL;
3042 }
3043 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3044
3045 wxPyUserData* data = NULL;
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3048 if ( userData && (info.window || info.sizer || info.gotSize) )
3049 data = new wxPyUserData(userData);
3050 wxPyEndBlockThreads(blocked);
3051
3052 // Now call the real Prepend method if a valid item type was found
3053 if ( info.window )
3054 return self->Prepend(info.window, proportion, flag, border, data);
3055 else if ( info.sizer )
3056 return self->Prepend(info.sizer, proportion, flag, border, data);
3057 else if (info.gotSize)
3058 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3059 proportion, flag, border, data);
3060 else
3061 return NULL;
3062 }
3063 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3066 wxPyEndBlockThreads(blocked);
3067 if ( info.window )
3068 return self->Remove(info.window);
3069 else if ( info.sizer )
3070 return self->Remove(info.sizer);
3071 else if ( info.gotPos )
3072 return self->Remove(info.pos);
3073 else
3074 return false;
3075 }
3076 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3079 wxPyEndBlockThreads(blocked);
3080 if ( info.window )
3081 return self->Detach(info.window);
3082 else if ( info.sizer )
3083 return self->Detach(info.sizer);
3084 else if ( info.gotPos )
3085 return self->Detach(info.pos);
3086 else
3087 return false;
3088 }
3089 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3092 wxPyEndBlockThreads(blocked);
3093 if ( info.window )
3094 return self->GetItem(info.window);
3095 else if ( info.sizer )
3096 return self->GetItem(info.sizer);
3097 else if ( info.gotPos )
3098 return self->GetItem(info.pos);
3099 else
3100 return NULL;
3101 }
3102 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3105 wxPyEndBlockThreads(blocked);
3106 if ( info.window )
3107 self->SetItemMinSize(info.window, size);
3108 else if ( info.sizer )
3109 self->SetItemMinSize(info.sizer, size);
3110 else if ( info.gotPos )
3111 self->SetItemMinSize(info.pos, size);
3112 }
3113 static PyObject *wxSizer_GetChildren(wxSizer *self){
3114 wxSizerItemList& list = self->GetChildren();
3115 return wxPy_ConvertList(&list);
3116 }
3117 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3120 wxPyEndBlockThreads(blocked);
3121 if ( info.window )
3122 return self->Show(info.window, show, recursive);
3123 else if ( info.sizer )
3124 return self->Show(info.sizer, show, recursive);
3125 else if ( info.gotPos )
3126 return self->Show(info.pos, show);
3127 else
3128 return false;
3129 }
3130 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3131 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3132 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3133 wxPyEndBlockThreads(blocked);
3134 if ( info.window )
3135 return self->IsShown(info.window);
3136 else if ( info.sizer )
3137 return self->IsShown(info.sizer);
3138 else if ( info.gotPos )
3139 return self->IsShown(info.pos);
3140 else
3141 return false;
3142 }
3143
3144 // See pyclasses.h
3145 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3146 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3147 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3148
3149
3150
3151
3152 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3153 {
3154 if (source == Py_None) {
3155 **obj = wxGBPosition(-1,-1);
3156 return true;
3157 }
3158 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3159 }
3160
3161 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3162 {
3163 if (source == Py_None) {
3164 **obj = wxGBSpan(-1,-1);
3165 return true;
3166 }
3167 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3168 }
3169
3170
3171 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3172 self->SetRow(row);
3173 self->SetCol(col);
3174 }
3175 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 PyObject* tup = PyTuple_New(2);
3178 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3179 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3180 wxPyEndBlockThreads(blocked);
3181 return tup;
3182 }
3183 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3184 self->SetRowspan(rowspan);
3185 self->SetColspan(colspan);
3186 }
3187 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 PyObject* tup = PyTuple_New(2);
3190 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3191 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3192 wxPyEndBlockThreads(blocked);
3193 return tup;
3194 }
3195 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3196 wxPyUserData* data = NULL;
3197 if ( userData ) {
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201 }
3202 return new wxGBSizerItem(window, pos, span, flag, border, data);
3203 }
3204 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3205 wxPyUserData* data = NULL;
3206 if ( userData ) {
3207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3208 data = new wxPyUserData(userData);
3209 wxPyEndBlockThreads(blocked);
3210 }
3211 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3212 }
3213 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3214 wxPyUserData* data = NULL;
3215 if ( userData ) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3221 }
3222 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3223 int row, col;
3224 self->GetEndPos(row, col);
3225 return wxGBPosition(row, col);
3226 }
3227 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3228
3229 wxPyUserData* data = NULL;
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3232 if ( userData && (info.window || info.sizer || info.gotSize) )
3233 data = new wxPyUserData(userData);
3234 wxPyEndBlockThreads(blocked);
3235
3236 // Now call the real Add method if a valid item type was found
3237 if ( info.window )
3238 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3239 else if ( info.sizer )
3240 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3241 else if (info.gotSize)
3242 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3243 pos, span, flag, border, data);
3244 return NULL;
3245 }
3246
3247
3248 #ifdef __cplusplus
3249 extern "C" {
3250 #endif
3251 static int _wrap_EmptyString_set(PyObject *) {
3252 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3253 return 1;
3254 }
3255
3256
3257 static PyObject *_wrap_EmptyString_get(void) {
3258 PyObject *pyobj;
3259
3260 {
3261 #if wxUSE_UNICODE
3262 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3263 #else
3264 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3265 #endif
3266 }
3267 return pyobj;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 wxString result;
3275 PyObject * obj0 = 0 ;
3276 char *kwnames[] = {
3277 (char *) "self", NULL
3278 };
3279
3280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3282 if (SWIG_arg_fail(1)) SWIG_fail;
3283 {
3284 PyThreadState* __tstate = wxPyBeginAllowThreads();
3285 result = wxObject_GetClassName(arg1);
3286
3287 wxPyEndAllowThreads(__tstate);
3288 if (PyErr_Occurred()) SWIG_fail;
3289 }
3290 {
3291 #if wxUSE_UNICODE
3292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3293 #else
3294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3295 #endif
3296 }
3297 return resultobj;
3298 fail:
3299 return NULL;
3300 }
3301
3302
3303 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxObject *arg1 = (wxObject *) 0 ;
3306 PyObject * obj0 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 PyThreadState* __tstate = wxPyBeginAllowThreads();
3316 wxObject_Destroy(arg1);
3317
3318 wxPyEndAllowThreads(__tstate);
3319 if (PyErr_Occurred()) SWIG_fail;
3320 }
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3329 PyObject *obj;
3330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3331 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3332 Py_INCREF(obj);
3333 return Py_BuildValue((char *)"");
3334 }
3335 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3336 PyObject *resultobj;
3337 wxSize *arg1 = (wxSize *) 0 ;
3338 int arg2 ;
3339 PyObject * obj0 = 0 ;
3340 PyObject * obj1 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "self",(char *) "x", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 {
3349 arg2 = (int)(SWIG_As_int(obj1));
3350 if (SWIG_arg_fail(2)) SWIG_fail;
3351 }
3352 if (arg1) (arg1)->x = arg2;
3353
3354 Py_INCREF(Py_None); resultobj = Py_None;
3355 return resultobj;
3356 fail:
3357 return NULL;
3358 }
3359
3360
3361 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj;
3363 wxSize *arg1 = (wxSize *) 0 ;
3364 int result;
3365 PyObject * obj0 = 0 ;
3366 char *kwnames[] = {
3367 (char *) "self", NULL
3368 };
3369
3370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3372 if (SWIG_arg_fail(1)) SWIG_fail;
3373 result = (int) ((arg1)->x);
3374
3375 {
3376 resultobj = SWIG_From_int((int)(result));
3377 }
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxSize *arg1 = (wxSize *) 0 ;
3387 int arg2 ;
3388 PyObject * obj0 = 0 ;
3389 PyObject * obj1 = 0 ;
3390 char *kwnames[] = {
3391 (char *) "self",(char *) "y", NULL
3392 };
3393
3394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3396 if (SWIG_arg_fail(1)) SWIG_fail;
3397 {
3398 arg2 = (int)(SWIG_As_int(obj1));
3399 if (SWIG_arg_fail(2)) SWIG_fail;
3400 }
3401 if (arg1) (arg1)->y = arg2;
3402
3403 Py_INCREF(Py_None); resultobj = Py_None;
3404 return resultobj;
3405 fail:
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxSize *arg1 = (wxSize *) 0 ;
3413 int result;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "self", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 result = (int) ((arg1)->y);
3423
3424 {
3425 resultobj = SWIG_From_int((int)(result));
3426 }
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 int arg1 = (int) 0 ;
3436 int arg2 = (int) 0 ;
3437 wxSize *result;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "w",(char *) "h", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3445 if (obj0) {
3446 {
3447 arg1 = (int)(SWIG_As_int(obj0));
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 }
3450 }
3451 if (obj1) {
3452 {
3453 arg2 = (int)(SWIG_As_int(obj1));
3454 if (SWIG_arg_fail(2)) SWIG_fail;
3455 }
3456 }
3457 {
3458 PyThreadState* __tstate = wxPyBeginAllowThreads();
3459 result = (wxSize *)new wxSize(arg1,arg2);
3460
3461 wxPyEndAllowThreads(__tstate);
3462 if (PyErr_Occurred()) SWIG_fail;
3463 }
3464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxSize *arg1 = (wxSize *) 0 ;
3474 PyObject * obj0 = 0 ;
3475 char *kwnames[] = {
3476 (char *) "self", NULL
3477 };
3478
3479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 delete arg1;
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 Py_INCREF(Py_None); resultobj = Py_None;
3490 return resultobj;
3491 fail:
3492 return NULL;
3493 }
3494
3495
3496 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3497 PyObject *resultobj;
3498 wxSize *arg1 = (wxSize *) 0 ;
3499 wxSize *arg2 = 0 ;
3500 bool result;
3501 wxSize temp2 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self",(char *) "sz", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 arg2 = &temp2;
3513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 return resultobj;
3526 fail:
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 wxSize *arg1 = (wxSize *) 0 ;
3534 wxSize *arg2 = 0 ;
3535 bool result;
3536 wxSize temp2 ;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "self",(char *) "sz", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3545 if (SWIG_arg_fail(1)) SWIG_fail;
3546 {
3547 arg2 = &temp2;
3548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3559 }
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
3566 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj;
3568 wxSize *arg1 = (wxSize *) 0 ;
3569 wxSize *arg2 = 0 ;
3570 wxSize result;
3571 wxSize temp2 ;
3572 PyObject * obj0 = 0 ;
3573 PyObject * obj1 = 0 ;
3574 char *kwnames[] = {
3575 (char *) "self",(char *) "sz", NULL
3576 };
3577
3578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 {
3582 arg2 = &temp2;
3583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (arg1)->operator +((wxSize const &)*arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 {
3593 wxSize * resultptr;
3594 resultptr = new wxSize((wxSize &)(result));
3595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 wxSize *arg1 = (wxSize *) 0 ;
3606 wxSize *arg2 = 0 ;
3607 wxSize result;
3608 wxSize temp2 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "self",(char *) "sz", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 {
3619 arg2 = &temp2;
3620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (arg1)->operator -((wxSize const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 wxSize * resultptr;
3631 resultptr = new wxSize((wxSize &)(result));
3632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->IncTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 wxSize *arg2 = 0 ;
3676 wxSize temp2 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "sz", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = &temp2;
3688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3689 }
3690 {
3691 PyThreadState* __tstate = wxPyBeginAllowThreads();
3692 (arg1)->DecTo((wxSize const &)*arg2);
3693
3694 wxPyEndAllowThreads(__tstate);
3695 if (PyErr_Occurred()) SWIG_fail;
3696 }
3697 Py_INCREF(Py_None); resultobj = Py_None;
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 wxSize *arg1 = (wxSize *) 0 ;
3707 int arg2 ;
3708 int arg3 ;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 PyObject * obj2 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self",(char *) "w",(char *) "h", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 arg2 = (int)(SWIG_As_int(obj1));
3721 if (SWIG_arg_fail(2)) SWIG_fail;
3722 }
3723 {
3724 arg3 = (int)(SWIG_As_int(obj2));
3725 if (SWIG_arg_fail(3)) SWIG_fail;
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 (arg1)->Set(arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 Py_INCREF(Py_None); resultobj = Py_None;
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxSize *arg1 = (wxSize *) 0 ;
3744 int arg2 ;
3745 PyObject * obj0 = 0 ;
3746 PyObject * obj1 = 0 ;
3747 char *kwnames[] = {
3748 (char *) "self",(char *) "w", NULL
3749 };
3750
3751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3753 if (SWIG_arg_fail(1)) SWIG_fail;
3754 {
3755 arg2 = (int)(SWIG_As_int(obj1));
3756 if (SWIG_arg_fail(2)) SWIG_fail;
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 (arg1)->SetWidth(arg2);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 Py_INCREF(Py_None); resultobj = Py_None;
3766 return resultobj;
3767 fail:
3768 return NULL;
3769 }
3770
3771
3772 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3773 PyObject *resultobj;
3774 wxSize *arg1 = (wxSize *) 0 ;
3775 int arg2 ;
3776 PyObject * obj0 = 0 ;
3777 PyObject * obj1 = 0 ;
3778 char *kwnames[] = {
3779 (char *) "self",(char *) "h", NULL
3780 };
3781
3782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3784 if (SWIG_arg_fail(1)) SWIG_fail;
3785 {
3786 arg2 = (int)(SWIG_As_int(obj1));
3787 if (SWIG_arg_fail(2)) SWIG_fail;
3788 }
3789 {
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 (arg1)->SetHeight(arg2);
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 wxSize *arg1 = (wxSize *) 0 ;
3806 int result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "self", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3814 if (SWIG_arg_fail(1)) SWIG_fail;
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 result = (int)((wxSize const *)arg1)->GetWidth();
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 {
3823 resultobj = SWIG_From_int((int)(result));
3824 }
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 wxSize *arg1 = (wxSize *) 0 ;
3834 int result;
3835 PyObject * obj0 = 0 ;
3836 char *kwnames[] = {
3837 (char *) "self", NULL
3838 };
3839
3840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3842 if (SWIG_arg_fail(1)) SWIG_fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = (int)((wxSize const *)arg1)->GetHeight();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 resultobj = SWIG_From_int((int)(result));
3852 }
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxSize *arg1 = (wxSize *) 0 ;
3862 bool result;
3863 PyObject * obj0 = 0 ;
3864 char *kwnames[] = {
3865 (char *) "self", NULL
3866 };
3867
3868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3870 if (SWIG_arg_fail(1)) SWIG_fail;
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 wxSize *arg2 = 0 ;
3891 wxSize temp2 ;
3892 PyObject * obj0 = 0 ;
3893 PyObject * obj1 = 0 ;
3894 char *kwnames[] = {
3895 (char *) "self",(char *) "size", NULL
3896 };
3897
3898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3900 if (SWIG_arg_fail(1)) SWIG_fail;
3901 {
3902 arg2 = &temp2;
3903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3904 }
3905 {
3906 PyThreadState* __tstate = wxPyBeginAllowThreads();
3907 (arg1)->SetDefaults((wxSize const &)*arg2);
3908
3909 wxPyEndAllowThreads(__tstate);
3910 if (PyErr_Occurred()) SWIG_fail;
3911 }
3912 Py_INCREF(Py_None); resultobj = Py_None;
3913 return resultobj;
3914 fail:
3915 return NULL;
3916 }
3917
3918
3919 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxSize *arg1 = (wxSize *) 0 ;
3922 PyObject *result;
3923 PyObject * obj0 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (PyObject *)wxSize_Get(arg1);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 resultobj = result;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3946 PyObject *obj;
3947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3948 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3949 Py_INCREF(obj);
3950 return Py_BuildValue((char *)"");
3951 }
3952 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3955 double arg2 ;
3956 PyObject * obj0 = 0 ;
3957 PyObject * obj1 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self",(char *) "x", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 arg2 = (double)(SWIG_As_double(obj1));
3967 if (SWIG_arg_fail(2)) SWIG_fail;
3968 }
3969 if (arg1) (arg1)->x = arg2;
3970
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3981 double result;
3982 PyObject * obj0 = 0 ;
3983 char *kwnames[] = {
3984 (char *) "self", NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3989 if (SWIG_arg_fail(1)) SWIG_fail;
3990 result = (double) ((arg1)->x);
3991
3992 {
3993 resultobj = SWIG_From_double((double)(result));
3994 }
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4004 double arg2 ;
4005 PyObject * obj0 = 0 ;
4006 PyObject * obj1 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "self",(char *) "y", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4013 if (SWIG_arg_fail(1)) SWIG_fail;
4014 {
4015 arg2 = (double)(SWIG_As_double(obj1));
4016 if (SWIG_arg_fail(2)) SWIG_fail;
4017 }
4018 if (arg1) (arg1)->y = arg2;
4019
4020 Py_INCREF(Py_None); resultobj = Py_None;
4021 return resultobj;
4022 fail:
4023 return NULL;
4024 }
4025
4026
4027 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4028 PyObject *resultobj;
4029 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4030 double result;
4031 PyObject * obj0 = 0 ;
4032 char *kwnames[] = {
4033 (char *) "self", NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4038 if (SWIG_arg_fail(1)) SWIG_fail;
4039 result = (double) ((arg1)->y);
4040
4041 {
4042 resultobj = SWIG_From_double((double)(result));
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 double arg1 = (double) 0.0 ;
4053 double arg2 = (double) 0.0 ;
4054 wxRealPoint *result;
4055 PyObject * obj0 = 0 ;
4056 PyObject * obj1 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "x",(char *) "y", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4062 if (obj0) {
4063 {
4064 arg1 = (double)(SWIG_As_double(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 }
4068 if (obj1) {
4069 {
4070 arg2 = (double)(SWIG_As_double(obj1));
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 }
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "self", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 delete arg1;
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 Py_INCREF(Py_None); resultobj = Py_None;
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4116 wxRealPoint *arg2 = 0 ;
4117 bool result;
4118 wxRealPoint temp2 ;
4119 PyObject * obj0 = 0 ;
4120 PyObject * obj1 = 0 ;
4121 char *kwnames[] = {
4122 (char *) "self",(char *) "pt", NULL
4123 };
4124
4125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 {
4129 arg2 = &temp2;
4130 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4141 }
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4151 wxRealPoint *arg2 = 0 ;
4152 bool result;
4153 wxRealPoint temp2 ;
4154 PyObject * obj0 = 0 ;
4155 PyObject * obj1 = 0 ;
4156 char *kwnames[] = {
4157 (char *) "self",(char *) "pt", NULL
4158 };
4159
4160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 {
4164 arg2 = &temp2;
4165 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4176 }
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj;
4185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4186 wxRealPoint *arg2 = 0 ;
4187 wxRealPoint result;
4188 wxRealPoint temp2 ;
4189 PyObject * obj0 = 0 ;
4190 PyObject * obj1 = 0 ;
4191 char *kwnames[] = {
4192 (char *) "self",(char *) "pt", NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 {
4199 arg2 = &temp2;
4200 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 {
4210 wxRealPoint * resultptr;
4211 resultptr = new wxRealPoint((wxRealPoint &)(result));
4212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4213 }
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4223 wxRealPoint *arg2 = 0 ;
4224 wxRealPoint result;
4225 wxRealPoint temp2 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 char *kwnames[] = {
4229 (char *) "self",(char *) "pt", NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4234 if (SWIG_arg_fail(1)) SWIG_fail;
4235 {
4236 arg2 = &temp2;
4237 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 {
4247 wxRealPoint * resultptr;
4248 resultptr = new wxRealPoint((wxRealPoint &)(result));
4249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4250 }
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4260 double arg2 ;
4261 double arg3 ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 PyObject * obj2 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self",(char *) "x",(char *) "y", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 arg2 = (double)(SWIG_As_double(obj1));
4274 if (SWIG_arg_fail(2)) SWIG_fail;
4275 }
4276 {
4277 arg3 = (double)(SWIG_As_double(obj2));
4278 if (SWIG_arg_fail(3)) SWIG_fail;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxRealPoint_Set(arg1,arg2,arg3);
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 Py_INCREF(Py_None); resultobj = Py_None;
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4297 PyObject *result;
4298 PyObject * obj0 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = (PyObject *)wxRealPoint_Get(arg1);
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 resultobj = result;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4321 PyObject *obj;
4322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4323 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4324 Py_INCREF(obj);
4325 return Py_BuildValue((char *)"");
4326 }
4327 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxPoint *arg1 = (wxPoint *) 0 ;
4330 int arg2 ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char *kwnames[] = {
4334 (char *) "self",(char *) "x", NULL
4335 };
4336
4337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4339 if (SWIG_arg_fail(1)) SWIG_fail;
4340 {
4341 arg2 = (int)(SWIG_As_int(obj1));
4342 if (SWIG_arg_fail(2)) SWIG_fail;
4343 }
4344 if (arg1) (arg1)->x = arg2;
4345
4346 Py_INCREF(Py_None); resultobj = Py_None;
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4354 PyObject *resultobj;
4355 wxPoint *arg1 = (wxPoint *) 0 ;
4356 int result;
4357 PyObject * obj0 = 0 ;
4358 char *kwnames[] = {
4359 (char *) "self", NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4364 if (SWIG_arg_fail(1)) SWIG_fail;
4365 result = (int) ((arg1)->x);
4366
4367 {
4368 resultobj = SWIG_From_int((int)(result));
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxPoint *arg1 = (wxPoint *) 0 ;
4379 int arg2 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self",(char *) "y", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 arg2 = (int)(SWIG_As_int(obj1));
4391 if (SWIG_arg_fail(2)) SWIG_fail;
4392 }
4393 if (arg1) (arg1)->y = arg2;
4394
4395 Py_INCREF(Py_None); resultobj = Py_None;
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxPoint *arg1 = (wxPoint *) 0 ;
4405 int result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 result = (int) ((arg1)->y);
4415
4416 {
4417 resultobj = SWIG_From_int((int)(result));
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 int arg1 = (int) 0 ;
4428 int arg2 = (int) 0 ;
4429 wxPoint *result;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "x",(char *) "y", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = (int)(SWIG_As_int(obj0));
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 }
4442 }
4443 if (obj1) {
4444 {
4445 arg2 = (int)(SWIG_As_int(obj1));
4446 if (SWIG_arg_fail(2)) SWIG_fail;
4447 }
4448 }
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (wxPoint *)new wxPoint(arg1,arg2);
4452
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj;
4465 wxPoint *arg1 = (wxPoint *) 0 ;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 delete arg1;
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 Py_INCREF(Py_None); resultobj = Py_None;
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxPoint *arg1 = (wxPoint *) 0 ;
4491 wxPoint *arg2 = 0 ;
4492 bool result;
4493 wxPoint temp2 ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self",(char *) "pt", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4510
4511 wxPyEndAllowThreads(__tstate);
4512 if (PyErr_Occurred()) SWIG_fail;
4513 }
4514 {
4515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516 }
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxPoint *arg1 = (wxPoint *) 0 ;
4526 wxPoint *arg2 = 0 ;
4527 bool result;
4528 wxPoint temp2 ;
4529 PyObject * obj0 = 0 ;
4530 PyObject * obj1 = 0 ;
4531 char *kwnames[] = {
4532 (char *) "self",(char *) "pt", NULL
4533 };
4534
4535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(1)) SWIG_fail;
4538 {
4539 arg2 = &temp2;
4540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4541 }
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj;
4560 wxPoint *arg1 = (wxPoint *) 0 ;
4561 wxPoint *arg2 = 0 ;
4562 wxPoint result;
4563 wxPoint temp2 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char *kwnames[] = {
4567 (char *) "self",(char *) "pt", NULL
4568 };
4569
4570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4572 if (SWIG_arg_fail(1)) SWIG_fail;
4573 {
4574 arg2 = &temp2;
4575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (arg1)->operator +((wxPoint const &)*arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 wxPoint * resultptr;
4586 resultptr = new wxPoint((wxPoint &)(result));
4587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4588 }
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxPoint *arg1 = (wxPoint *) 0 ;
4598 wxPoint *arg2 = 0 ;
4599 wxPoint result;
4600 wxPoint temp2 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self",(char *) "pt", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 arg2 = &temp2;
4612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4613 }
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = (arg1)->operator -((wxPoint const &)*arg2);
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 {
4622 wxPoint * resultptr;
4623 resultptr = new wxPoint((wxPoint &)(result));
4624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4625 }
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxPoint *arg1 = (wxPoint *) 0 ;
4635 wxPoint *arg2 = 0 ;
4636 wxPoint *result;
4637 wxPoint temp2 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self",(char *) "pt", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 arg2 = &temp2;
4649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 {
4654 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4655 result = (wxPoint *) &_result_ref;
4656 }
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 wxPoint *arg2 = 0 ;
4672 wxPoint *result;
4673 wxPoint temp2 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "pt", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = &temp2;
4685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4686 }
4687 {
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 {
4690 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4691 result = (wxPoint *) &_result_ref;
4692 }
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj;
4706 wxPoint *arg1 = (wxPoint *) 0 ;
4707 long arg2 ;
4708 long arg3 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "x",(char *) "y", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = (long)(SWIG_As_long(obj1));
4721 if (SWIG_arg_fail(2)) SWIG_fail;
4722 }
4723 {
4724 arg3 = (long)(SWIG_As_long(obj2));
4725 if (SWIG_arg_fail(3)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 wxPoint_Set(arg1,arg2,arg3);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 Py_INCREF(Py_None); resultobj = Py_None;
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 wxPoint *arg1 = (wxPoint *) 0 ;
4744 PyObject *result;
4745 PyObject * obj0 = 0 ;
4746 char *kwnames[] = {
4747 (char *) "self", NULL
4748 };
4749
4750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (PyObject *)wxPoint_Get(arg1);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = result;
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4768 PyObject *obj;
4769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4770 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4771 Py_INCREF(obj);
4772 return Py_BuildValue((char *)"");
4773 }
4774 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj;
4776 int arg1 = (int) 0 ;
4777 int arg2 = (int) 0 ;
4778 int arg3 = (int) 0 ;
4779 int arg4 = (int) 0 ;
4780 wxRect *result;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 PyObject * obj2 = 0 ;
4784 PyObject * obj3 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4790 if (obj0) {
4791 {
4792 arg1 = (int)(SWIG_As_int(obj0));
4793 if (SWIG_arg_fail(1)) SWIG_fail;
4794 }
4795 }
4796 if (obj1) {
4797 {
4798 arg2 = (int)(SWIG_As_int(obj1));
4799 if (SWIG_arg_fail(2)) SWIG_fail;
4800 }
4801 }
4802 if (obj2) {
4803 {
4804 arg3 = (int)(SWIG_As_int(obj2));
4805 if (SWIG_arg_fail(3)) SWIG_fail;
4806 }
4807 }
4808 if (obj3) {
4809 {
4810 arg4 = (int)(SWIG_As_int(obj3));
4811 if (SWIG_arg_fail(4)) SWIG_fail;
4812 }
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxPoint *arg1 = 0 ;
4831 wxPoint *arg2 = 0 ;
4832 wxRect *result;
4833 wxPoint temp1 ;
4834 wxPoint temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "topLeft",(char *) "bottomRight", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4842 {
4843 arg1 = &temp1;
4844 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4845 }
4846 {
4847 arg2 = &temp2;
4848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4849 }
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxPoint *arg1 = 0 ;
4867 wxSize *arg2 = 0 ;
4868 wxRect *result;
4869 wxPoint temp1 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "pos",(char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 {
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4894 return resultobj;
4895 fail:
4896 return NULL;
4897 }
4898
4899
4900 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4901 PyObject *resultobj;
4902 wxSize *arg1 = 0 ;
4903 wxRect *result;
4904 wxSize temp1 ;
4905 PyObject * obj0 = 0 ;
4906 char *kwnames[] = {
4907 (char *) "size", NULL
4908 };
4909
4910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4911 {
4912 arg1 = &temp1;
4913 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxRect *arg1 = (wxRect *) 0 ;
4932 PyObject * obj0 = 0 ;
4933 char *kwnames[] = {
4934 (char *) "self", NULL
4935 };
4936
4937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4939 if (SWIG_arg_fail(1)) SWIG_fail;
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 delete arg1;
4943
4944 wxPyEndAllowThreads(__tstate);
4945 if (PyErr_Occurred()) SWIG_fail;
4946 }
4947 Py_INCREF(Py_None); resultobj = Py_None;
4948 return resultobj;
4949 fail:
4950 return NULL;
4951 }
4952
4953
4954 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4955 PyObject *resultobj;
4956 wxRect *arg1 = (wxRect *) 0 ;
4957 int result;
4958 PyObject * obj0 = 0 ;
4959 char *kwnames[] = {
4960 (char *) "self", NULL
4961 };
4962
4963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4965 if (SWIG_arg_fail(1)) SWIG_fail;
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 result = (int)((wxRect const *)arg1)->GetX();
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 {
4974 resultobj = SWIG_From_int((int)(result));
4975 }
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj;
4984 wxRect *arg1 = (wxRect *) 0 ;
4985 int arg2 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "self",(char *) "x", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4994 if (SWIG_arg_fail(1)) SWIG_fail;
4995 {
4996 arg2 = (int)(SWIG_As_int(obj1));
4997 if (SWIG_arg_fail(2)) SWIG_fail;
4998 }
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->SetX(arg2);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 Py_INCREF(Py_None); resultobj = Py_None;
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj;
5015 wxRect *arg1 = (wxRect *) 0 ;
5016 int result;
5017 PyObject * obj0 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "self", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5024 if (SWIG_arg_fail(1)) SWIG_fail;
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (int)(arg1)->GetY();
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = SWIG_From_int((int)(result));
5034 }
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5042 PyObject *resultobj;
5043 wxRect *arg1 = (wxRect *) 0 ;
5044 int arg2 ;
5045 PyObject * obj0 = 0 ;
5046 PyObject * obj1 = 0 ;
5047 char *kwnames[] = {
5048 (char *) "self",(char *) "y", NULL
5049 };
5050
5051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5053 if (SWIG_arg_fail(1)) SWIG_fail;
5054 {
5055 arg2 = (int)(SWIG_As_int(obj1));
5056 if (SWIG_arg_fail(2)) SWIG_fail;
5057 }
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 (arg1)->SetY(arg2);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 Py_INCREF(Py_None); resultobj = Py_None;
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj;
5074 wxRect *arg1 = (wxRect *) 0 ;
5075 int result;
5076 PyObject * obj0 = 0 ;
5077 char *kwnames[] = {
5078 (char *) "self", NULL
5079 };
5080
5081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5083 if (SWIG_arg_fail(1)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (int)((wxRect const *)arg1)->GetWidth();
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 {
5092 resultobj = SWIG_From_int((int)(result));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5101 PyObject *resultobj;
5102 wxRect *arg1 = (wxRect *) 0 ;
5103 int arg2 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char *kwnames[] = {
5107 (char *) "self",(char *) "w", NULL
5108 };
5109
5110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5112 if (SWIG_arg_fail(1)) SWIG_fail;
5113 {
5114 arg2 = (int)(SWIG_As_int(obj1));
5115 if (SWIG_arg_fail(2)) SWIG_fail;
5116 }
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 (arg1)->SetWidth(arg2);
5120
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 Py_INCREF(Py_None); resultobj = Py_None;
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxRect *arg1 = (wxRect *) 0 ;
5134 int result;
5135 PyObject * obj0 = 0 ;
5136 char *kwnames[] = {
5137 (char *) "self", NULL
5138 };
5139
5140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5142 if (SWIG_arg_fail(1)) SWIG_fail;
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 result = (int)((wxRect const *)arg1)->GetHeight();
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 {
5151 resultobj = SWIG_From_int((int)(result));
5152 }
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxRect *arg1 = (wxRect *) 0 ;
5162 int arg2 ;
5163 PyObject * obj0 = 0 ;
5164 PyObject * obj1 = 0 ;
5165 char *kwnames[] = {
5166 (char *) "self",(char *) "h", NULL
5167 };
5168
5169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5171 if (SWIG_arg_fail(1)) SWIG_fail;
5172 {
5173 arg2 = (int)(SWIG_As_int(obj1));
5174 if (SWIG_arg_fail(2)) SWIG_fail;
5175 }
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 (arg1)->SetHeight(arg2);
5179
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 Py_INCREF(Py_None); resultobj = Py_None;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj;
5192 wxRect *arg1 = (wxRect *) 0 ;
5193 wxPoint result;
5194 PyObject * obj0 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = ((wxRect const *)arg1)->GetPosition();
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 wxPoint * resultptr;
5211 resultptr = new wxPoint((wxPoint &)(result));
5212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5213 }
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxPoint *arg2 = 0 ;
5224 wxPoint temp2 ;
5225 PyObject * obj0 = 0 ;
5226 PyObject * obj1 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self",(char *) "p", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 arg2 = &temp2;
5236 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5237 }
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 (arg1)->SetPosition((wxPoint const &)*arg2);
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 Py_INCREF(Py_None); resultobj = Py_None;
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxRect *arg1 = (wxRect *) 0 ;
5255 wxSize result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 result = ((wxRect const *)arg1)->GetSize();
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 wxSize * resultptr;
5273 resultptr = new wxSize((wxSize &)(result));
5274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 wxSize *arg2 = 0 ;
5286 wxSize temp2 ;
5287 PyObject * obj0 = 0 ;
5288 PyObject * obj1 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "self",(char *) "s", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5295 if (SWIG_arg_fail(1)) SWIG_fail;
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 (arg1)->SetSize((wxSize const &)*arg2);
5303
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 Py_INCREF(Py_None); resultobj = Py_None;
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxRect *arg1 = (wxRect *) 0 ;
5317 bool result;
5318 PyObject * obj0 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 result = (bool)((wxRect const *)arg1)->IsEmpty();
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 {
5334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetTopLeft();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 wxPoint result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = ((wxRect const *)arg1)->GetBottomRight();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 wxPoint * resultptr;
5425 resultptr = new wxPoint((wxPoint &)(result));
5426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 wxPoint *arg2 = 0 ;
5438 wxPoint temp2 ;
5439 PyObject * obj0 = 0 ;
5440 PyObject * obj1 = 0 ;
5441 char *kwnames[] = {
5442 (char *) "self",(char *) "p", NULL
5443 };
5444
5445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5447 if (SWIG_arg_fail(1)) SWIG_fail;
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5455
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 Py_INCREF(Py_None); resultobj = Py_None;
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj;
5468 wxRect *arg1 = (wxRect *) 0 ;
5469 int result;
5470 PyObject * obj0 = 0 ;
5471 char *kwnames[] = {
5472 (char *) "self", NULL
5473 };
5474
5475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5477 if (SWIG_arg_fail(1)) SWIG_fail;
5478 {
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = (int)((wxRect const *)arg1)->GetLeft();
5481
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 resultobj = SWIG_From_int((int)(result));
5487 }
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5495 PyObject *resultobj;
5496 wxRect *arg1 = (wxRect *) 0 ;
5497 int result;
5498 PyObject * obj0 = 0 ;
5499 char *kwnames[] = {
5500 (char *) "self", NULL
5501 };
5502
5503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5505 if (SWIG_arg_fail(1)) SWIG_fail;
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = (int)((wxRect const *)arg1)->GetTop();
5509
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 resultobj = SWIG_From_int((int)(result));
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj;
5524 wxRect *arg1 = (wxRect *) 0 ;
5525 int result;
5526 PyObject * obj0 = 0 ;
5527 char *kwnames[] = {
5528 (char *) "self", NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(1)) SWIG_fail;
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (int)((wxRect const *)arg1)->GetBottom();
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_int((int)(result));
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj;
5552 wxRect *arg1 = (wxRect *) 0 ;
5553 int result;
5554 PyObject * obj0 = 0 ;
5555 char *kwnames[] = {
5556 (char *) "self", NULL
5557 };
5558
5559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5561 if (SWIG_arg_fail(1)) SWIG_fail;
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = (int)((wxRect const *)arg1)->GetRight();
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 {
5570 resultobj = SWIG_From_int((int)(result));
5571 }
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "left", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetLeft(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "right", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetRight(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 PyObject * obj0 = 0 ;
5645 PyObject * obj1 = 0 ;
5646 char *kwnames[] = {
5647 (char *) "self",(char *) "top", NULL
5648 };
5649
5650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5652 if (SWIG_arg_fail(1)) SWIG_fail;
5653 {
5654 arg2 = (int)(SWIG_As_int(obj1));
5655 if (SWIG_arg_fail(2)) SWIG_fail;
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 (arg1)->SetTop(arg2);
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 Py_INCREF(Py_None); resultobj = Py_None;
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "self",(char *) "bottom", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 {
5685 arg2 = (int)(SWIG_As_int(obj1));
5686 if (SWIG_arg_fail(2)) SWIG_fail;
5687 }
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 (arg1)->SetBottom(arg2);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 Py_INCREF(Py_None); resultobj = Py_None;
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj;
5704 wxRect *arg1 = (wxRect *) 0 ;
5705 int arg2 ;
5706 int arg3 ;
5707 wxRect *result;
5708 PyObject * obj0 = 0 ;
5709 PyObject * obj1 = 0 ;
5710 PyObject * obj2 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self",(char *) "dx",(char *) "dy", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 arg2 = (int)(SWIG_As_int(obj1));
5720 if (SWIG_arg_fail(2)) SWIG_fail;
5721 }
5722 {
5723 arg3 = (int)(SWIG_As_int(obj2));
5724 if (SWIG_arg_fail(3)) SWIG_fail;
5725 }
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 {
5729 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5730 result = (wxRect *) &_result_ref;
5731 }
5732
5733 wxPyEndAllowThreads(__tstate);
5734 if (PyErr_Occurred()) SWIG_fail;
5735 }
5736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxRect *arg1 = (wxRect *) 0 ;
5746 int arg2 ;
5747 int arg3 ;
5748 wxRect *result;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 PyObject * obj2 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self",(char *) "dx",(char *) "dy", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 arg2 = (int)(SWIG_As_int(obj1));
5761 if (SWIG_arg_fail(2)) SWIG_fail;
5762 }
5763 {
5764 arg3 = (int)(SWIG_As_int(obj2));
5765 if (SWIG_arg_fail(3)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 {
5770 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5771 result = (wxRect *) &_result_ref;
5772 }
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxRect *arg1 = (wxRect *) 0 ;
5787 int arg2 ;
5788 int arg3 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "dx",(char *) "dy", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = (int)(SWIG_As_int(obj1));
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 arg3 = (int)(SWIG_As_int(obj2));
5805 if (SWIG_arg_fail(3)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset(arg2,arg3);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxPoint *arg2 = 0 ;
5825 wxPoint temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "pt", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 (arg1)->Offset((wxPoint const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 Py_INCREF(Py_None); resultobj = Py_None;
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->Intersect((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (arg1)->Union((wxRect const &)*arg2);
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 wxRect * resultptr;
5918 resultptr = new wxRect((wxRect &)(result));
5919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxRect *arg1 = (wxRect *) 0 ;
5930 wxRect *arg2 = 0 ;
5931 wxRect result;
5932 wxRect temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "self",(char *) "rect", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5941 if (SWIG_arg_fail(1)) SWIG_fail;
5942 {
5943 arg2 = &temp2;
5944 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 {
5954 wxRect * resultptr;
5955 resultptr = new wxRect((wxRect &)(result));
5956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxRect *arg1 = (wxRect *) 0 ;
5967 wxRect *arg2 = 0 ;
5968 wxRect *result;
5969 wxRect temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char *kwnames[] = {
5973 (char *) "self",(char *) "rect", NULL
5974 };
5975
5976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5978 if (SWIG_arg_fail(1)) SWIG_fail;
5979 {
5980 arg2 = &temp2;
5981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5982 }
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 {
5986 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5987 result = (wxRect *) &_result_ref;
5988 }
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 wxRect *arg2 = 0 ;
6004 bool result;
6005 wxRect temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char *kwnames[] = {
6009 (char *) "self",(char *) "rect", NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6014 if (SWIG_arg_fail(1)) SWIG_fail;
6015 {
6016 arg2 = &temp2;
6017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6018 }
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6028 }
6029 return resultobj;
6030 fail:
6031 return NULL;
6032 }
6033
6034
6035 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6036 PyObject *resultobj;
6037 wxRect *arg1 = (wxRect *) 0 ;
6038 wxRect *arg2 = 0 ;
6039 bool result;
6040 wxRect temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "self",(char *) "rect", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 {
6051 arg2 = &temp2;
6052 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6053 }
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxRect *arg1 = (wxRect *) 0 ;
6073 int arg2 ;
6074 int arg3 ;
6075 bool result;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 PyObject * obj2 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "x",(char *) "y", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = (int)(SWIG_As_int(obj1));
6088 if (SWIG_arg_fail(2)) SWIG_fail;
6089 }
6090 {
6091 arg3 = (int)(SWIG_As_int(obj2));
6092 if (SWIG_arg_fail(3)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 wxPoint *arg2 = 0 ;
6114 bool result;
6115 wxPoint temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char *kwnames[] = {
6119 (char *) "self",(char *) "pt", NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6124 if (SWIG_arg_fail(1)) SWIG_fail;
6125 {
6126 arg2 = &temp2;
6127 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6128 }
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6132
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6138 }
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 wxRect *arg2 = 0 ;
6149 bool result;
6150 wxRect temp2 ;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "self",(char *) "rect", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6159 if (SWIG_arg_fail(1)) SWIG_fail;
6160 {
6161 arg2 = &temp2;
6162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 {
6172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6173 }
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxRect *arg1 = (wxRect *) 0 ;
6183 int arg2 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self",(char *) "x", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 arg2 = (int)(SWIG_As_int(obj1));
6195 if (SWIG_arg_fail(2)) SWIG_fail;
6196 }
6197 if (arg1) (arg1)->x = arg2;
6198
6199 Py_INCREF(Py_None); resultobj = Py_None;
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 result = (int) ((arg1)->x);
6219
6220 {
6221 resultobj = SWIG_From_int((int)(result));
6222 }
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "y", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = (int)(SWIG_As_int(obj1));
6244 if (SWIG_arg_fail(2)) SWIG_fail;
6245 }
6246 if (arg1) (arg1)->y = arg2;
6247
6248 Py_INCREF(Py_None); resultobj = Py_None;
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int result;
6259 PyObject * obj0 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 result = (int) ((arg1)->y);
6268
6269 {
6270 resultobj = SWIG_From_int((int)(result));
6271 }
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int arg2 ;
6282 PyObject * obj0 = 0 ;
6283 PyObject * obj1 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self",(char *) "width", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 {
6292 arg2 = (int)(SWIG_As_int(obj1));
6293 if (SWIG_arg_fail(2)) SWIG_fail;
6294 }
6295 if (arg1) (arg1)->width = arg2;
6296
6297 Py_INCREF(Py_None); resultobj = Py_None;
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 result = (int) ((arg1)->width);
6317
6318 {
6319 resultobj = SWIG_From_int((int)(result));
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int arg2 ;
6331 PyObject * obj0 = 0 ;
6332 PyObject * obj1 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self",(char *) "height", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 arg2 = (int)(SWIG_As_int(obj1));
6342 if (SWIG_arg_fail(2)) SWIG_fail;
6343 }
6344 if (arg1) (arg1)->height = arg2;
6345
6346 Py_INCREF(Py_None); resultobj = Py_None;
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 result = (int) ((arg1)->height);
6366
6367 {
6368 resultobj = SWIG_From_int((int)(result));
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxRect *arg1 = (wxRect *) 0 ;
6379 int arg2 = (int) 0 ;
6380 int arg3 = (int) 0 ;
6381 int arg4 = (int) 0 ;
6382 int arg5 = (int) 0 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 PyObject * obj3 = 0 ;
6387 PyObject * obj4 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 if (obj1) {
6396 {
6397 arg2 = (int)(SWIG_As_int(obj1));
6398 if (SWIG_arg_fail(2)) SWIG_fail;
6399 }
6400 }
6401 if (obj2) {
6402 {
6403 arg3 = (int)(SWIG_As_int(obj2));
6404 if (SWIG_arg_fail(3)) SWIG_fail;
6405 }
6406 }
6407 if (obj3) {
6408 {
6409 arg4 = (int)(SWIG_As_int(obj3));
6410 if (SWIG_arg_fail(4)) SWIG_fail;
6411 }
6412 }
6413 if (obj4) {
6414 {
6415 arg5 = (int)(SWIG_As_int(obj4));
6416 if (SWIG_arg_fail(5)) SWIG_fail;
6417 }
6418 }
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 Py_INCREF(Py_None); resultobj = Py_None;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 PyObject *result;
6437 PyObject * obj0 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (PyObject *)wxRect_Get(arg1);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = result;
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6460 PyObject *obj;
6461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6462 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6463 Py_INCREF(obj);
6464 return Py_BuildValue((char *)"");
6465 }
6466 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 wxRect *arg2 = (wxRect *) 0 ;
6470 PyObject *result;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "r1",(char *) "r2", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(2)) SWIG_fail;
6482 {
6483 if (!wxPyCheckForApp()) SWIG_fail;
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (PyObject *)wxIntersectRect(arg1,arg2);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = result;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 double arg1 = (double) 0.0 ;
6500 double arg2 = (double) 0.0 ;
6501 wxPoint2D *result;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "x",(char *) "y", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6509 if (obj0) {
6510 {
6511 arg1 = (double)(SWIG_As_double(obj0));
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 }
6514 }
6515 if (obj1) {
6516 {
6517 arg2 = (double)(SWIG_As_double(obj1));
6518 if (SWIG_arg_fail(2)) SWIG_fail;
6519 }
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxPoint2D *arg1 = 0 ;
6538 wxPoint2D *result;
6539 wxPoint2D temp1 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "pt", NULL
6543 };
6544
6545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6546 {
6547 arg1 = &temp1;
6548 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6549 }
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6558 return resultobj;
6559 fail:
6560 return NULL;
6561 }
6562
6563
6564 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6565 PyObject *resultobj;
6566 wxPoint *arg1 = 0 ;
6567 wxPoint2D *result;
6568 wxPoint temp1 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "pt", NULL
6572 };
6573
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6575 {
6576 arg1 = &temp1;
6577 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 int *arg2 = (int *) 0 ;
6597 int *arg3 = (int *) 0 ;
6598 int temp2 ;
6599 int res2 = 0 ;
6600 int temp3 ;
6601 int res3 = 0 ;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 Py_INCREF(Py_None); resultobj = Py_None;
6620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6631 PyObject *resultobj;
6632 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6633 int *arg2 = (int *) 0 ;
6634 int *arg3 = (int *) 0 ;
6635 int temp2 ;
6636 int res2 = 0 ;
6637 int temp3 ;
6638 int res3 = 0 ;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6645 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 Py_INCREF(Py_None); resultobj = Py_None;
6657 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6658 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6659 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6660 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6670 double result;
6671 PyObject * obj0 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 {
6687 resultobj = SWIG_From_double((double)(result));
6688 }
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6696 PyObject *resultobj;
6697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6698 double result;
6699 PyObject * obj0 = 0 ;
6700 char *kwnames[] = {
6701 (char *) "self", NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6706 if (SWIG_arg_fail(1)) SWIG_fail;
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = SWIG_From_double((double)(result));
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 double arg2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self",(char *) "length", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 arg2 = (double)(SWIG_As_double(obj1));
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 }
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 (arg1)->SetVectorLength(arg2);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 Py_INCREF(Py_None); resultobj = Py_None;
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj;
6756 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6757 double arg2 ;
6758 PyObject * obj0 = 0 ;
6759 PyObject * obj1 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "self",(char *) "degrees", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6766 if (SWIG_arg_fail(1)) SWIG_fail;
6767 {
6768 arg2 = (double)(SWIG_As_double(obj1));
6769 if (SWIG_arg_fail(2)) SWIG_fail;
6770 }
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 (arg1)->SetVectorAngle(arg2);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 Py_INCREF(Py_None); resultobj = Py_None;
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "pt", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "pt", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D *arg2 = 0 ;
6859 double result;
6860 wxPoint2D temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char *kwnames[] = {
6864 (char *) "self",(char *) "vec", NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6869 if (SWIG_arg_fail(1)) SWIG_fail;
6870 {
6871 arg2 = &temp2;
6872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6873 }
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 resultobj = SWIG_From_double((double)(result));
6883 }
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6891 PyObject *resultobj;
6892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6893 wxPoint2D *arg2 = 0 ;
6894 double result;
6895 wxPoint2D temp2 ;
6896 PyObject * obj0 = 0 ;
6897 PyObject * obj1 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self",(char *) "vec", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6904 if (SWIG_arg_fail(1)) SWIG_fail;
6905 {
6906 arg2 = &temp2;
6907 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6908 }
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 {
6917 resultobj = SWIG_From_double((double)(result));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj;
6927 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6928 wxPoint2D result;
6929 PyObject * obj0 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "self", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (arg1)->operator -();
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 {
6945 wxPoint2D * resultptr;
6946 resultptr = new wxPoint2D((wxPoint2D &)(result));
6947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 wxPoint2D *result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7050 result = (wxPoint2D *) &_result_ref;
7051 }
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj;
7065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7066 wxPoint2D *arg2 = 0 ;
7067 wxPoint2D *result;
7068 wxPoint2D temp2 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "pt", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 arg2 = &temp2;
7080 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7081 }
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7086 result = (wxPoint2D *) &_result_ref;
7087 }
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 wxPoint2D *arg2 = 0 ;
7103 bool result;
7104 wxPoint2D temp2 ;
7105 PyObject * obj0 = 0 ;
7106 PyObject * obj1 = 0 ;
7107 char *kwnames[] = {
7108 (char *) "self",(char *) "pt", NULL
7109 };
7110
7111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7113 if (SWIG_arg_fail(1)) SWIG_fail;
7114 {
7115 arg2 = &temp2;
7116 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 {
7126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 wxPoint2D *arg2 = 0 ;
7138 bool result;
7139 wxPoint2D temp2 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "pt", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 arg2 = &temp2;
7151 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7172 double arg2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self",(char *) "m_x", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 {
7183 arg2 = (double)(SWIG_As_double(obj1));
7184 if (SWIG_arg_fail(2)) SWIG_fail;
7185 }
7186 if (arg1) (arg1)->m_x = arg2;
7187
7188 Py_INCREF(Py_None); resultobj = Py_None;
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double result;
7199 PyObject * obj0 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 result = (double) ((arg1)->m_x);
7208
7209 {
7210 resultobj = SWIG_From_double((double)(result));
7211 }
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7221 double arg2 ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "m_y", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 arg2 = (double)(SWIG_As_double(obj1));
7233 if (SWIG_arg_fail(2)) SWIG_fail;
7234 }
7235 if (arg1) (arg1)->m_y = arg2;
7236
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 double result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 result = (double) ((arg1)->m_y);
7257
7258 {
7259 resultobj = SWIG_From_double((double)(result));
7260 }
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7270 double arg2 = (double) 0 ;
7271 double arg3 = (double) 0 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 PyObject * obj2 = 0 ;
7275 char *kwnames[] = {
7276 (char *) "self",(char *) "x",(char *) "y", NULL
7277 };
7278
7279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7281 if (SWIG_arg_fail(1)) SWIG_fail;
7282 if (obj1) {
7283 {
7284 arg2 = (double)(SWIG_As_double(obj1));
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 }
7287 }
7288 if (obj2) {
7289 {
7290 arg3 = (double)(SWIG_As_double(obj2));
7291 if (SWIG_arg_fail(3)) SWIG_fail;
7292 }
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 wxPoint2D_Set(arg1,arg2,arg3);
7297
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 Py_INCREF(Py_None); resultobj = Py_None;
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7311 PyObject *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (PyObject *)wxPoint2D_Get(arg1);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = result;
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7335 PyObject *obj;
7336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7337 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7338 Py_INCREF(obj);
7339 return Py_BuildValue((char *)"");
7340 }
7341 static int _wrap_DefaultPosition_set(PyObject *) {
7342 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7343 return 1;
7344 }
7345
7346
7347 static PyObject *_wrap_DefaultPosition_get(void) {
7348 PyObject *pyobj;
7349
7350 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7351 return pyobj;
7352 }
7353
7354
7355 static int _wrap_DefaultSize_set(PyObject *) {
7356 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7357 return 1;
7358 }
7359
7360
7361 static PyObject *_wrap_DefaultSize_get(void) {
7362 PyObject *pyobj;
7363
7364 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7365 return pyobj;
7366 }
7367
7368
7369 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 PyObject *arg1 = (PyObject *) 0 ;
7372 wxPyInputStream *result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "p", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7379 arg1 = obj0;
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj;
7396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 delete arg1;
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7422 PyObject * obj0 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 (arg1)->close();
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 Py_INCREF(Py_None); resultobj = Py_None;
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->flush();
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 bool result;
7473 PyObject * obj0 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->eof();
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 {
7489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7490 }
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7500 int arg2 = (int) -1 ;
7501 PyObject *result;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "self",(char *) "size", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7510 if (SWIG_arg_fail(1)) SWIG_fail;
7511 if (obj1) {
7512 {
7513 arg2 = (int)(SWIG_As_int(obj1));
7514 if (SWIG_arg_fail(2)) SWIG_fail;
7515 }
7516 }
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (PyObject *)(arg1)->read(arg2);
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 resultobj = result;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7534 int arg2 = (int) -1 ;
7535 PyObject *result;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "size", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 if (obj1) {
7546 {
7547 arg2 = (int)(SWIG_As_int(obj1));
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 }
7550 }
7551 {
7552 PyThreadState* __tstate = wxPyBeginAllowThreads();
7553 result = (PyObject *)(arg1)->readline(arg2);
7554
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 resultobj = result;
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7566 PyObject *resultobj;
7567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7568 int arg2 = (int) -1 ;
7569 PyObject *result;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char *kwnames[] = {
7573 (char *) "self",(char *) "sizehint", NULL
7574 };
7575
7576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7578 if (SWIG_arg_fail(1)) SWIG_fail;
7579 if (obj1) {
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (PyObject *)(arg1)->readlines(arg2);
7588
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = result;
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7602 int arg2 ;
7603 int arg3 = (int) 0 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 PyObject * obj2 = 0 ;
7607 char *kwnames[] = {
7608 (char *) "self",(char *) "offset",(char *) "whence", NULL
7609 };
7610
7611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7613 if (SWIG_arg_fail(1)) SWIG_fail;
7614 {
7615 arg2 = (int)(SWIG_As_int(obj1));
7616 if (SWIG_arg_fail(2)) SWIG_fail;
7617 }
7618 if (obj2) {
7619 {
7620 arg3 = (int)(SWIG_As_int(obj2));
7621 if (SWIG_arg_fail(3)) SWIG_fail;
7622 }
7623 }
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->seek(arg2,arg3);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 Py_INCREF(Py_None); resultobj = Py_None;
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj;
7640 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7641 int result;
7642 PyObject * obj0 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (int)(arg1)->tell();
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = SWIG_From_int((int)(result));
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj;
7668 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7669 char result;
7670 PyObject * obj0 = 0 ;
7671 char *kwnames[] = {
7672 (char *) "self", NULL
7673 };
7674
7675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7677 if (SWIG_arg_fail(1)) SWIG_fail;
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 result = (char)(arg1)->Peek();
7681
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 {
7686 resultobj = SWIG_From_char((char)(result));
7687 }
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj;
7696 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7697 char result;
7698 PyObject * obj0 = 0 ;
7699 char *kwnames[] = {
7700 (char *) "self", NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(1)) SWIG_fail;
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 result = (char)(arg1)->GetC();
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 {
7714 resultobj = SWIG_From_char((char)(result));
7715 }
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7723 PyObject *resultobj;
7724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7725 size_t result;
7726 PyObject * obj0 = 0 ;
7727 char *kwnames[] = {
7728 (char *) "self", NULL
7729 };
7730
7731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7733 if (SWIG_arg_fail(1)) SWIG_fail;
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 result = (size_t)(arg1)->LastRead();
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7753 bool result;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->CanRead();
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 bool result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "self", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7789 if (SWIG_arg_fail(1)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (bool)(arg1)->Eof();
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7809 char arg2 ;
7810 bool result;
7811 PyObject * obj0 = 0 ;
7812 PyObject * obj1 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self",(char *) "c", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 arg2 = (char)(SWIG_As_char(obj1));
7822 if (SWIG_arg_fail(2)) SWIG_fail;
7823 }
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (bool)(arg1)->Ungetch(arg2);
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7841 PyObject *resultobj;
7842 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7843 long arg2 ;
7844 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7845 long result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 PyObject * obj2 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "pos",(char *) "mode", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 {
7857 arg2 = (long)(SWIG_As_long(obj1));
7858 if (SWIG_arg_fail(2)) SWIG_fail;
7859 }
7860 if (obj2) {
7861 {
7862 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7863 if (SWIG_arg_fail(3)) SWIG_fail;
7864 }
7865 }
7866 {
7867 PyThreadState* __tstate = wxPyBeginAllowThreads();
7868 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7869
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 {
7874 resultobj = SWIG_From_long((long)(result));
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7885 long result;
7886 PyObject * obj0 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (long)(arg1)->TellI();
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = SWIG_From_long((long)(result));
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7911 PyObject *obj;
7912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7913 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7914 Py_INCREF(obj);
7915 return Py_BuildValue((char *)"");
7916 }
7917 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj;
7919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7920 PyObject *arg2 = (PyObject *) 0 ;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self",(char *) "obj", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 arg2 = obj1;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 wxOutputStream_write(arg1,arg2);
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 Py_INCREF(Py_None); resultobj = Py_None;
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7946 PyObject *obj;
7947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7948 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7949 Py_INCREF(obj);
7950 return Py_BuildValue((char *)"");
7951 }
7952 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxInputStream *arg1 = (wxInputStream *) 0 ;
7955 wxString *arg2 = 0 ;
7956 wxString *arg3 = 0 ;
7957 wxString *arg4 = 0 ;
7958 wxDateTime arg5 ;
7959 wxFSFile *result;
7960 wxPyInputStream *temp1 ;
7961 bool temp2 = false ;
7962 bool temp3 = false ;
7963 bool temp4 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 PyObject * obj2 = 0 ;
7967 PyObject * obj3 = 0 ;
7968 PyObject * obj4 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7974 {
7975 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7976 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7977 } else {
7978 PyErr_Clear(); // clear the failure of the wxPyConvert above
7979 arg1 = wxPyCBInputStream_create(obj0, true);
7980 if (arg1 == NULL) {
7981 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7982 SWIG_fail;
7983 }
7984 }
7985 }
7986 {
7987 arg2 = wxString_in_helper(obj1);
7988 if (arg2 == NULL) SWIG_fail;
7989 temp2 = true;
7990 }
7991 {
7992 arg3 = wxString_in_helper(obj2);
7993 if (arg3 == NULL) SWIG_fail;
7994 temp3 = true;
7995 }
7996 {
7997 arg4 = wxString_in_helper(obj3);
7998 if (arg4 == NULL) SWIG_fail;
7999 temp4 = true;
8000 }
8001 {
8002 wxDateTime * argp;
8003 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8004 if (SWIG_arg_fail(5)) SWIG_fail;
8005 if (argp == NULL) {
8006 SWIG_null_ref("wxDateTime");
8007 }
8008 if (SWIG_arg_fail(5)) SWIG_fail;
8009 arg5 = *argp;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 {
8019 resultobj = wxPyMake_wxObject(result, 1);
8020 }
8021 {
8022 if (temp2)
8023 delete arg2;
8024 }
8025 {
8026 if (temp3)
8027 delete arg3;
8028 }
8029 {
8030 if (temp4)
8031 delete arg4;
8032 }
8033 return resultobj;
8034 fail:
8035 {
8036 if (temp2)
8037 delete arg2;
8038 }
8039 {
8040 if (temp3)
8041 delete arg3;
8042 }
8043 {
8044 if (temp4)
8045 delete arg4;
8046 }
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxFSFile *arg1 = (wxFSFile *) 0 ;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 delete arg1;
8065
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 Py_INCREF(Py_None); resultobj = Py_None;
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj;
8078 wxFSFile *arg1 = (wxFSFile *) 0 ;
8079 wxInputStream *result;
8080 PyObject * obj0 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxInputStream *)(arg1)->GetStream();
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 wxPyInputStream * _ptr = NULL;
8097
8098 if (result) {
8099 _ptr = new wxPyInputStream(result);
8100 }
8101 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj;
8111 wxFSFile *arg1 = (wxFSFile *) 0 ;
8112 wxString *result;
8113 PyObject * obj0 = 0 ;
8114 char *kwnames[] = {
8115 (char *) "self", NULL
8116 };
8117
8118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8120 if (SWIG_arg_fail(1)) SWIG_fail;
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 {
8124 wxString const &_result_ref = (arg1)->GetMimeType();
8125 result = (wxString *) &_result_ref;
8126 }
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 {
8132 #if wxUSE_UNICODE
8133 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8134 #else
8135 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8136 #endif
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj;
8146 wxFSFile *arg1 = (wxFSFile *) 0 ;
8147 wxString *result;
8148 PyObject * obj0 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 {
8159 wxString const &_result_ref = (arg1)->GetLocation();
8160 result = (wxString *) &_result_ref;
8161 }
8162
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 {
8167 #if wxUSE_UNICODE
8168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8169 #else
8170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8171 #endif
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj;
8181 wxFSFile *arg1 = (wxFSFile *) 0 ;
8182 wxString *result;
8183 PyObject * obj0 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 {
8194 wxString const &_result_ref = (arg1)->GetAnchor();
8195 result = (wxString *) &_result_ref;
8196 }
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 #if wxUSE_UNICODE
8203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8204 #else
8205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8206 #endif
8207 }
8208 return resultobj;
8209 fail:
8210 return NULL;
8211 }
8212
8213
8214 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxFSFile *arg1 = (wxFSFile *) 0 ;
8217 wxDateTime result;
8218 PyObject * obj0 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "self", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (arg1)->GetModificationTime();
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 wxDateTime * resultptr;
8235 resultptr = new wxDateTime((wxDateTime &)(result));
8236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8237 }
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8252 PyObject *obj;
8253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8254 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8255 Py_INCREF(obj);
8256 return Py_BuildValue((char *)"");
8257 }
8258 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyFileSystemHandler *result;
8261 char *kwnames[] = {
8262 NULL
8263 };
8264
8265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8283 PyObject *arg2 = (PyObject *) 0 ;
8284 PyObject *arg3 = (PyObject *) 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 PyObject * obj2 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self",(char *) "self",(char *) "_class", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 arg2 = obj1;
8296 arg3 = obj2;
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 (arg1)->_setCallbackInfo(arg2,arg3);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 Py_INCREF(Py_None); resultobj = Py_None;
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8314 wxString *arg2 = 0 ;
8315 bool result;
8316 bool temp2 = false ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self",(char *) "location", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 arg2 = wxString_in_helper(obj1);
8328 if (arg2 == NULL) SWIG_fail;
8329 temp2 = true;
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8340 }
8341 {
8342 if (temp2)
8343 delete arg2;
8344 }
8345 return resultobj;
8346 fail:
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8358 wxFileSystem *arg2 = 0 ;
8359 wxString *arg3 = 0 ;
8360 wxFSFile *result;
8361 bool temp3 = false ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 PyObject * obj2 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self",(char *) "fs",(char *) "location", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 {
8373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(2)) SWIG_fail;
8375 if (arg2 == NULL) {
8376 SWIG_null_ref("wxFileSystem");
8377 }
8378 if (SWIG_arg_fail(2)) SWIG_fail;
8379 }
8380 {
8381 arg3 = wxString_in_helper(obj2);
8382 if (arg3 == NULL) SWIG_fail;
8383 temp3 = true;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = wxPyMake_wxObject(result, 1);
8394 }
8395 {
8396 if (temp3)
8397 delete arg3;
8398 }
8399 return resultobj;
8400 fail:
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8412 wxString *arg2 = 0 ;
8413 int arg3 = (int) 0 ;
8414 wxString result;
8415 bool temp2 = false ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "spec",(char *) "flags", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 arg2 = wxString_in_helper(obj1);
8428 if (arg2 == NULL) SWIG_fail;
8429 temp2 = true;
8430 }
8431 if (obj2) {
8432 {
8433 arg3 = (int)(SWIG_As_int(obj2));
8434 if (SWIG_arg_fail(3)) SWIG_fail;
8435 }
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 #if wxUSE_UNICODE
8446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8447 #else
8448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8449 #endif
8450 }
8451 {
8452 if (temp2)
8453 delete arg2;
8454 }
8455 return resultobj;
8456 fail:
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (arg1)->FindNext();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 #if wxUSE_UNICODE
8486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8487 #else
8488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8489 #endif
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj;
8499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8500 wxString *arg2 = 0 ;
8501 wxString result;
8502 bool temp2 = false ;
8503 PyObject * obj0 = 0 ;
8504 PyObject * obj1 = 0 ;
8505 char *kwnames[] = {
8506 (char *) "self",(char *) "location", NULL
8507 };
8508
8509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8511 if (SWIG_arg_fail(1)) SWIG_fail;
8512 {
8513 arg2 = wxString_in_helper(obj1);
8514 if (arg2 == NULL) SWIG_fail;
8515 temp2 = true;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (arg1)->GetProtocol((wxString const &)*arg2);
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 #if wxUSE_UNICODE
8526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8527 #else
8528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8529 #endif
8530 }
8531 {
8532 if (temp2)
8533 delete arg2;
8534 }
8535 return resultobj;
8536 fail:
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8548 wxString *arg2 = 0 ;
8549 wxString result;
8550 bool temp2 = false ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self",(char *) "location", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 arg2 = wxString_in_helper(obj1);
8562 if (arg2 == NULL) SWIG_fail;
8563 temp2 = true;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 #if wxUSE_UNICODE
8574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8575 #else
8576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8577 #endif
8578 }
8579 {
8580 if (temp2)
8581 delete arg2;
8582 }
8583 return resultobj;
8584 fail:
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj;
8595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8596 wxString *arg2 = 0 ;
8597 wxString result;
8598 bool temp2 = false ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self",(char *) "location", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 arg2 = wxString_in_helper(obj1);
8610 if (arg2 == NULL) SWIG_fail;
8611 temp2 = true;
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (arg1)->GetAnchor((wxString const &)*arg2);
8616
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 #if wxUSE_UNICODE
8622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8623 #else
8624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8625 #endif
8626 }
8627 {
8628 if (temp2)
8629 delete arg2;
8630 }
8631 return resultobj;
8632 fail:
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return NULL;
8638 }
8639
8640
8641 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8644 wxString *arg2 = 0 ;
8645 wxString result;
8646 bool temp2 = false ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "self",(char *) "location", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 {
8657 arg2 = wxString_in_helper(obj1);
8658 if (arg2 == NULL) SWIG_fail;
8659 temp2 = true;
8660 }
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8664
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 {
8669 #if wxUSE_UNICODE
8670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8671 #else
8672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8673 #endif
8674 }
8675 {
8676 if (temp2)
8677 delete arg2;
8678 }
8679 return resultobj;
8680 fail:
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return NULL;
8686 }
8687
8688
8689 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj;
8691 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8692 wxString *arg2 = 0 ;
8693 wxString result;
8694 bool temp2 = false ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char *kwnames[] = {
8698 (char *) "self",(char *) "location", NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8703 if (SWIG_arg_fail(1)) SWIG_fail;
8704 {
8705 arg2 = wxString_in_helper(obj1);
8706 if (arg2 == NULL) SWIG_fail;
8707 temp2 = true;
8708 }
8709 {
8710 PyThreadState* __tstate = wxPyBeginAllowThreads();
8711 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8712
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 {
8717 #if wxUSE_UNICODE
8718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8719 #else
8720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8721 #endif
8722 }
8723 {
8724 if (temp2)
8725 delete arg2;
8726 }
8727 return resultobj;
8728 fail:
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return NULL;
8734 }
8735
8736
8737 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8738 PyObject *obj;
8739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8740 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8741 Py_INCREF(obj);
8742 return Py_BuildValue((char *)"");
8743 }
8744 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj;
8746 wxFileSystem *result;
8747 char *kwnames[] = {
8748 NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 result = (wxFileSystem *)new wxFileSystem();
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = wxPyMake_wxObject(result, 1);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj;
8770 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8771 PyObject * obj0 = 0 ;
8772 char *kwnames[] = {
8773 (char *) "self", NULL
8774 };
8775
8776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8778 if (SWIG_arg_fail(1)) SWIG_fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 delete arg1;
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 Py_INCREF(Py_None); resultobj = Py_None;
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8796 wxString *arg2 = 0 ;
8797 bool arg3 = (bool) false ;
8798 bool temp2 = false ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 arg2 = wxString_in_helper(obj1);
8811 if (arg2 == NULL) SWIG_fail;
8812 temp2 = true;
8813 }
8814 if (obj2) {
8815 {
8816 arg3 = (bool)(SWIG_As_bool(obj2));
8817 if (SWIG_arg_fail(3)) SWIG_fail;
8818 }
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 Py_INCREF(Py_None); resultobj = Py_None;
8828 {
8829 if (temp2)
8830 delete arg2;
8831 }
8832 return resultobj;
8833 fail:
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString result;
8846 PyObject * obj0 = 0 ;
8847 char *kwnames[] = {
8848 (char *) "self", NULL
8849 };
8850
8851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (arg1)->GetPath();
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 {
8862 #if wxUSE_UNICODE
8863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8864 #else
8865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8866 #endif
8867 }
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8877 wxString *arg2 = 0 ;
8878 wxFSFile *result;
8879 bool temp2 = false ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "location", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 {
8890 arg2 = wxString_in_helper(obj1);
8891 if (arg2 == NULL) SWIG_fail;
8892 temp2 = true;
8893 }
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 resultobj = wxPyMake_wxObject(result, 1);
8903 }
8904 {
8905 if (temp2)
8906 delete arg2;
8907 }
8908 return resultobj;
8909 fail:
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return NULL;
8915 }
8916
8917
8918 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj;
8920 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8921 wxString *arg2 = 0 ;
8922 int arg3 = (int) 0 ;
8923 wxString result;
8924 bool temp2 = false ;
8925 PyObject * obj0 = 0 ;
8926 PyObject * obj1 = 0 ;
8927 PyObject * obj2 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self",(char *) "spec",(char *) "flags", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 arg2 = wxString_in_helper(obj1);
8937 if (arg2 == NULL) SWIG_fail;
8938 temp2 = true;
8939 }
8940 if (obj2) {
8941 {
8942 arg3 = (int)(SWIG_As_int(obj2));
8943 if (SWIG_arg_fail(3)) SWIG_fail;
8944 }
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 #if wxUSE_UNICODE
8955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8956 #else
8957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8958 #endif
8959 }
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return resultobj;
8965 fail:
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8977 wxString result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "self", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (arg1)->FindNext();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9009 PyObject * obj0 = 0 ;
9010 char *kwnames[] = {
9011 (char *) "handler", NULL
9012 };
9013
9014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9016 if (SWIG_arg_fail(1)) SWIG_fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxFileSystem::AddHandler(arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 char *kwnames[] = {
9034 NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxFileSystem::CleanUpHandlers();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxString *arg1 = 0 ;
9055 wxString result;
9056 bool temp1 = false ;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "filename", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9063 {
9064 arg1 = wxString_in_helper(obj0);
9065 if (arg1 == NULL) SWIG_fail;
9066 temp1 = true;
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 {
9076 #if wxUSE_UNICODE
9077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9078 #else
9079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9080 #endif
9081 }
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxString *arg1 = 0 ;
9099 wxString result;
9100 bool temp1 = false ;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "url", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9107 {
9108 arg1 = wxString_in_helper(obj0);
9109 if (arg1 == NULL) SWIG_fail;
9110 temp1 = true;
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = FileSystem_URLToFileName((wxString const &)*arg1);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 {
9120 #if wxUSE_UNICODE
9121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9122 #else
9123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9124 #endif
9125 }
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return resultobj;
9131 fail:
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return NULL;
9137 }
9138
9139
9140 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9141 PyObject *obj;
9142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9143 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9144 Py_INCREF(obj);
9145 return Py_BuildValue((char *)"");
9146 }
9147 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxInternetFSHandler *result;
9150 char *kwnames[] = {
9151 NULL
9152 };
9153
9154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj;
9171 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9172 wxString *arg2 = 0 ;
9173 bool result;
9174 bool temp2 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 char *kwnames[] = {
9178 (char *) "self",(char *) "location", NULL
9179 };
9180
9181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9183 if (SWIG_arg_fail(1)) SWIG_fail;
9184 {
9185 arg2 = wxString_in_helper(obj1);
9186 if (arg2 == NULL) SWIG_fail;
9187 temp2 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 {
9197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9198 }
9199 {
9200 if (temp2)
9201 delete arg2;
9202 }
9203 return resultobj;
9204 fail:
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9216 wxFileSystem *arg2 = 0 ;
9217 wxString *arg3 = 0 ;
9218 wxFSFile *result;
9219 bool temp3 = false ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char *kwnames[] = {
9224 (char *) "self",(char *) "fs",(char *) "location", NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9229 if (SWIG_arg_fail(1)) SWIG_fail;
9230 {
9231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9232 if (SWIG_arg_fail(2)) SWIG_fail;
9233 if (arg2 == NULL) {
9234 SWIG_null_ref("wxFileSystem");
9235 }
9236 if (SWIG_arg_fail(2)) SWIG_fail;
9237 }
9238 {
9239 arg3 = wxString_in_helper(obj2);
9240 if (arg3 == NULL) SWIG_fail;
9241 temp3 = true;
9242 }
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxPyMake_wxObject(result, 1);
9252 }
9253 {
9254 if (temp3)
9255 delete arg3;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9268 PyObject *obj;
9269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9270 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9271 Py_INCREF(obj);
9272 return Py_BuildValue((char *)"");
9273 }
9274 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxZipFSHandler *result;
9277 char *kwnames[] = {
9278 NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxZipFSHandler *)new wxZipFSHandler();
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9299 wxString *arg2 = 0 ;
9300 bool result;
9301 bool temp2 = false ;
9302 PyObject * obj0 = 0 ;
9303 PyObject * obj1 = 0 ;
9304 char *kwnames[] = {
9305 (char *) "self",(char *) "location", NULL
9306 };
9307
9308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9310 if (SWIG_arg_fail(1)) SWIG_fail;
9311 {
9312 arg2 = wxString_in_helper(obj1);
9313 if (arg2 == NULL) SWIG_fail;
9314 temp2 = true;
9315 }
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9325 }
9326 {
9327 if (temp2)
9328 delete arg2;
9329 }
9330 return resultobj;
9331 fail:
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9343 wxFileSystem *arg2 = 0 ;
9344 wxString *arg3 = 0 ;
9345 wxFSFile *result;
9346 bool temp3 = false ;
9347 PyObject * obj0 = 0 ;
9348 PyObject * obj1 = 0 ;
9349 PyObject * obj2 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self",(char *) "fs",(char *) "location", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(2)) SWIG_fail;
9360 if (arg2 == NULL) {
9361 SWIG_null_ref("wxFileSystem");
9362 }
9363 if (SWIG_arg_fail(2)) SWIG_fail;
9364 }
9365 {
9366 arg3 = wxString_in_helper(obj2);
9367 if (arg3 == NULL) SWIG_fail;
9368 temp3 = true;
9369 }
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = wxPyMake_wxObject(result, 1);
9379 }
9380 {
9381 if (temp3)
9382 delete arg3;
9383 }
9384 return resultobj;
9385 fail:
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return NULL;
9391 }
9392
9393
9394 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj;
9396 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9397 wxString *arg2 = 0 ;
9398 int arg3 = (int) 0 ;
9399 wxString result;
9400 bool temp2 = false ;
9401 PyObject * obj0 = 0 ;
9402 PyObject * obj1 = 0 ;
9403 PyObject * obj2 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self",(char *) "spec",(char *) "flags", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 arg2 = wxString_in_helper(obj1);
9413 if (arg2 == NULL) SWIG_fail;
9414 temp2 = true;
9415 }
9416 if (obj2) {
9417 {
9418 arg3 = (int)(SWIG_As_int(obj2));
9419 if (SWIG_arg_fail(3)) SWIG_fail;
9420 }
9421 }
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 #if wxUSE_UNICODE
9431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9432 #else
9433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9434 #endif
9435 }
9436 {
9437 if (temp2)
9438 delete arg2;
9439 }
9440 return resultobj;
9441 fail:
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return NULL;
9447 }
9448
9449
9450 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj;
9452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9453 wxString result;
9454 PyObject * obj0 = 0 ;
9455 char *kwnames[] = {
9456 (char *) "self", NULL
9457 };
9458
9459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9461 if (SWIG_arg_fail(1)) SWIG_fail;
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (arg1)->FindNext();
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9483 PyObject *obj;
9484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9485 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9486 Py_INCREF(obj);
9487 return Py_BuildValue((char *)"");
9488 }
9489 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxString *arg1 = 0 ;
9492 wxImage *arg2 = 0 ;
9493 long arg3 ;
9494 bool temp1 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 PyObject * obj2 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "filename",(char *) "image",(char *) "type", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9503 {
9504 arg1 = wxString_in_helper(obj0);
9505 if (arg1 == NULL) SWIG_fail;
9506 temp1 = true;
9507 }
9508 {
9509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(2)) SWIG_fail;
9511 if (arg2 == NULL) {
9512 SWIG_null_ref("wxImage");
9513 }
9514 if (SWIG_arg_fail(2)) SWIG_fail;
9515 }
9516 {
9517 arg3 = (long)(SWIG_As_long(obj2));
9518 if (SWIG_arg_fail(3)) SWIG_fail;
9519 }
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 Py_INCREF(Py_None); resultobj = Py_None;
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxString *arg1 = 0 ;
9545 wxBitmap *arg2 = 0 ;
9546 long arg3 ;
9547 bool temp1 = false ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 PyObject * obj2 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 {
9562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9563 if (SWIG_arg_fail(2)) SWIG_fail;
9564 if (arg2 == NULL) {
9565 SWIG_null_ref("wxBitmap");
9566 }
9567 if (SWIG_arg_fail(2)) SWIG_fail;
9568 }
9569 {
9570 arg3 = (long)(SWIG_As_long(obj2));
9571 if (SWIG_arg_fail(3)) SWIG_fail;
9572 }
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 Py_INCREF(Py_None); resultobj = Py_None;
9581 {
9582 if (temp1)
9583 delete arg1;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj;
9597 wxString *arg1 = 0 ;
9598 PyObject *arg2 = (PyObject *) 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 PyObject * obj1 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "filename",(char *) "data", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9607 {
9608 arg1 = wxString_in_helper(obj0);
9609 if (arg1 == NULL) SWIG_fail;
9610 temp1 = true;
9611 }
9612 arg2 = obj1;
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *result;
9638 char *kwnames[] = {
9639 NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxString *arg1 = 0 ;
9660 bool temp1 = false ;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "filename", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9667 {
9668 arg1 = wxString_in_helper(obj0);
9669 if (arg1 == NULL) SWIG_fail;
9670 temp1 = true;
9671 }
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 Py_INCREF(Py_None); resultobj = Py_None;
9680 {
9681 if (temp1)
9682 delete arg1;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9697 wxString *arg2 = 0 ;
9698 bool result;
9699 bool temp2 = false ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "self",(char *) "location", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(1)) SWIG_fail;
9709 {
9710 arg2 = wxString_in_helper(obj1);
9711 if (arg2 == NULL) SWIG_fail;
9712 temp2 = true;
9713 }
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9741 wxFileSystem *arg2 = 0 ;
9742 wxString *arg3 = 0 ;
9743 wxFSFile *result;
9744 bool temp3 = false ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 PyObject * obj2 = 0 ;
9748 char *kwnames[] = {
9749 (char *) "self",(char *) "fs",(char *) "location", NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9754 if (SWIG_arg_fail(1)) SWIG_fail;
9755 {
9756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(2)) SWIG_fail;
9758 if (arg2 == NULL) {
9759 SWIG_null_ref("wxFileSystem");
9760 }
9761 if (SWIG_arg_fail(2)) SWIG_fail;
9762 }
9763 {
9764 arg3 = wxString_in_helper(obj2);
9765 if (arg3 == NULL) SWIG_fail;
9766 temp3 = true;
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = wxPyMake_wxObject(result, 1);
9777 }
9778 {
9779 if (temp3)
9780 delete arg3;
9781 }
9782 return resultobj;
9783 fail:
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9795 wxString *arg2 = 0 ;
9796 int arg3 = (int) 0 ;
9797 wxString result;
9798 bool temp2 = false ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 PyObject * obj2 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self",(char *) "spec",(char *) "flags", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 arg2 = wxString_in_helper(obj1);
9811 if (arg2 == NULL) SWIG_fail;
9812 temp2 = true;
9813 }
9814 if (obj2) {
9815 {
9816 arg3 = (int)(SWIG_As_int(obj2));
9817 if (SWIG_arg_fail(3)) SWIG_fail;
9818 }
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 {
9828 #if wxUSE_UNICODE
9829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9830 #else
9831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9832 #endif
9833 }
9834 {
9835 if (temp2)
9836 delete arg2;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj;
9850 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9851 wxString result;
9852 PyObject * obj0 = 0 ;
9853 char *kwnames[] = {
9854 (char *) "self", NULL
9855 };
9856
9857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9859 if (SWIG_arg_fail(1)) SWIG_fail;
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->FindNext();
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9881 PyObject *obj;
9882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9883 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9884 Py_INCREF(obj);
9885 return Py_BuildValue((char *)"");
9886 }
9887 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9890 wxString result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (arg1)->GetName();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 #if wxUSE_UNICODE
9908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9909 #else
9910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9911 #endif
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 wxString result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetExtension();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9954 long result;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (long)(arg1)->GetType();
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 resultobj = SWIG_From_long((long)(result));
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString result;
9983 PyObject * obj0 = 0 ;
9984 char *kwnames[] = {
9985 (char *) "self", NULL
9986 };
9987
9988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9990 if (SWIG_arg_fail(1)) SWIG_fail;
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetMimeType();
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 {
9999 #if wxUSE_UNICODE
10000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10001 #else
10002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10003 #endif
10004 }
10005 return resultobj;
10006 fail:
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10014 wxString *arg2 = 0 ;
10015 bool result;
10016 bool temp2 = false ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 char *kwnames[] = {
10020 (char *) "self",(char *) "name", NULL
10021 };
10022
10023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10025 if (SWIG_arg_fail(1)) SWIG_fail;
10026 {
10027 arg2 = wxString_in_helper(obj1);
10028 if (arg2 == NULL) SWIG_fail;
10029 temp2 = true;
10030 }
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10034
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 return resultobj;
10046 fail:
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10058 wxString *arg2 = 0 ;
10059 bool temp2 = false ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char *kwnames[] = {
10063 (char *) "self",(char *) "name", NULL
10064 };
10065
10066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10068 if (SWIG_arg_fail(1)) SWIG_fail;
10069 {
10070 arg2 = wxString_in_helper(obj1);
10071 if (arg2 == NULL) SWIG_fail;
10072 temp2 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->SetName((wxString const &)*arg2);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 Py_INCREF(Py_None); resultobj = Py_None;
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 bool temp2 = false ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "self",(char *) "extension", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10109 if (SWIG_arg_fail(1)) SWIG_fail;
10110 {
10111 arg2 = wxString_in_helper(obj1);
10112 if (arg2 == NULL) SWIG_fail;
10113 temp2 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->SetExtension((wxString const &)*arg2);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp2)
10125 delete arg2;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10140 long arg2 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "type", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = (long)(SWIG_As_long(obj1));
10152 if (SWIG_arg_fail(2)) SWIG_fail;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 (arg1)->SetType(arg2);
10157
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 Py_INCREF(Py_None); resultobj = Py_None;
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj;
10170 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10171 wxString *arg2 = 0 ;
10172 bool temp2 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "mimetype", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 (arg1)->SetMimeType((wxString const &)*arg2);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 Py_INCREF(Py_None); resultobj = Py_None;
10195 {
10196 if (temp2)
10197 delete arg2;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10210 PyObject *obj;
10211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10212 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10213 Py_INCREF(obj);
10214 return Py_BuildValue((char *)"");
10215 }
10216 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxImageHistogram *result;
10219 char *kwnames[] = {
10220 NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (wxImageHistogram *)new wxImageHistogram();
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 unsigned char arg1 ;
10241 unsigned char arg2 ;
10242 unsigned char arg3 ;
10243 unsigned long result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "r",(char *) "g",(char *) "b", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 {
10253 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 }
10256 {
10257 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10258 if (SWIG_arg_fail(2)) SWIG_fail;
10259 }
10260 {
10261 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10262 if (SWIG_arg_fail(3)) SWIG_fail;
10263 }
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 {
10272 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10273 }
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10283 unsigned char *arg2 = (unsigned char *) 0 ;
10284 unsigned char *arg3 = (unsigned char *) 0 ;
10285 unsigned char *arg4 = (unsigned char *) 0 ;
10286 unsigned char arg5 = (unsigned char) 1 ;
10287 unsigned char arg6 = (unsigned char) 0 ;
10288 unsigned char arg7 = (unsigned char) 0 ;
10289 bool result;
10290 unsigned char temp2 ;
10291 int res2 = 0 ;
10292 unsigned char temp3 ;
10293 int res3 = 0 ;
10294 unsigned char temp4 ;
10295 int res4 = 0 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 PyObject * obj2 = 0 ;
10299 PyObject * obj3 = 0 ;
10300 char *kwnames[] = {
10301 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10302 };
10303
10304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10306 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 if (obj1) {
10311 {
10312 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10313 if (SWIG_arg_fail(5)) SWIG_fail;
10314 }
10315 }
10316 if (obj2) {
10317 {
10318 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10319 if (SWIG_arg_fail(6)) SWIG_fail;
10320 }
10321 }
10322 if (obj3) {
10323 {
10324 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10325 if (SWIG_arg_fail(7)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10337 }
10338 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10339 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10340 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10341 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10342 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10343 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10353 unsigned long arg2 ;
10354 unsigned long result;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self",(char *) "key", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10366 if (SWIG_arg_fail(2)) SWIG_fail;
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10377 }
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10387 unsigned char arg2 ;
10388 unsigned char arg3 ;
10389 unsigned char arg4 ;
10390 unsigned long result;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 PyObject * obj3 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10408 if (SWIG_arg_fail(3)) SWIG_fail;
10409 }
10410 {
10411 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10412 if (SWIG_arg_fail(4)) SWIG_fail;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10423 }
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10433 wxColour *arg2 = 0 ;
10434 unsigned long result;
10435 wxColour temp2 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438 char *kwnames[] = {
10439 (char *) "self",(char *) "colour", NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10444 if (SWIG_arg_fail(1)) SWIG_fail;
10445 {
10446 arg2 = &temp2;
10447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10458 }
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10466 PyObject *obj;
10467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10468 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10469 Py_INCREF(obj);
10470 return Py_BuildValue((char *)"");
10471 }
10472 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxString *arg1 = 0 ;
10475 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10476 int arg3 = (int) -1 ;
10477 wxImage *result;
10478 bool temp1 = false ;
10479 PyObject * obj0 = 0 ;
10480 PyObject * obj1 = 0 ;
10481 PyObject * obj2 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "name",(char *) "type",(char *) "index", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10487 {
10488 arg1 = wxString_in_helper(obj0);
10489 if (arg1 == NULL) SWIG_fail;
10490 temp1 = true;
10491 }
10492 if (obj1) {
10493 {
10494 arg2 = (long)(SWIG_As_long(obj1));
10495 if (SWIG_arg_fail(2)) SWIG_fail;
10496 }
10497 }
10498 if (obj2) {
10499 {
10500 arg3 = (int)(SWIG_As_int(obj2));
10501 if (SWIG_arg_fail(3)) SWIG_fail;
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10512 {
10513 if (temp1)
10514 delete arg1;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxImage *arg1 = (wxImage *) 0 ;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "self", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 delete arg1;
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 Py_INCREF(Py_None); resultobj = Py_None;
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxString *arg1 = 0 ;
10554 wxString *arg2 = 0 ;
10555 int arg3 = (int) -1 ;
10556 wxImage *result;
10557 bool temp1 = false ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 PyObject * obj2 = 0 ;
10562 char *kwnames[] = {
10563 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10564 };
10565
10566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10567 {
10568 arg1 = wxString_in_helper(obj0);
10569 if (arg1 == NULL) SWIG_fail;
10570 temp1 = true;
10571 }
10572 {
10573 arg2 = wxString_in_helper(obj1);
10574 if (arg2 == NULL) SWIG_fail;
10575 temp2 = true;
10576 }
10577 if (obj2) {
10578 {
10579 arg3 = (int)(SWIG_As_int(obj2));
10580 if (SWIG_arg_fail(3)) SWIG_fail;
10581 }
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxInputStream *arg1 = 0 ;
10616 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10617 int arg3 = (int) -1 ;
10618 wxImage *result;
10619 wxPyInputStream *temp1 ;
10620 bool created1 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "stream",(char *) "type",(char *) "index", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10629 {
10630 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10631 arg1 = temp1->m_wxis;
10632 created1 = false;
10633 } else {
10634 PyErr_Clear(); // clear the failure of the wxPyConvert above
10635 arg1 = wxPyCBInputStream_create(obj0, false);
10636 if (arg1 == NULL) {
10637 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10638 SWIG_fail;
10639 }
10640 created1 = true;
10641 }
10642 }
10643 if (obj1) {
10644 {
10645 arg2 = (long)(SWIG_As_long(obj1));
10646 if (SWIG_arg_fail(2)) SWIG_fail;
10647 }
10648 }
10649 if (obj2) {
10650 {
10651 arg3 = (int)(SWIG_As_int(obj2));
10652 if (SWIG_arg_fail(3)) SWIG_fail;
10653 }
10654 }
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10663 {
10664 if (created1) delete arg1;
10665 }
10666 return resultobj;
10667 fail:
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxInputStream *arg1 = 0 ;
10678 wxString *arg2 = 0 ;
10679 int arg3 = (int) -1 ;
10680 wxImage *result;
10681 wxPyInputStream *temp1 ;
10682 bool created1 ;
10683 bool temp2 = false ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 char *kwnames[] = {
10688 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10689 };
10690
10691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10692 {
10693 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10694 arg1 = temp1->m_wxis;
10695 created1 = false;
10696 } else {
10697 PyErr_Clear(); // clear the failure of the wxPyConvert above
10698 arg1 = wxPyCBInputStream_create(obj0, false);
10699 if (arg1 == NULL) {
10700 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10701 SWIG_fail;
10702 }
10703 created1 = true;
10704 }
10705 }
10706 {
10707 arg2 = wxString_in_helper(obj1);
10708 if (arg2 == NULL) SWIG_fail;
10709 temp2 = true;
10710 }
10711 if (obj2) {
10712 {
10713 arg3 = (int)(SWIG_As_int(obj2));
10714 if (SWIG_arg_fail(3)) SWIG_fail;
10715 }
10716 }
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10725 {
10726 if (created1) delete arg1;
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (created1) delete arg1;
10736 }
10737 {
10738 if (temp2)
10739 delete arg2;
10740 }
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 int arg1 = (int) 0 ;
10748 int arg2 = (int) 0 ;
10749 bool arg3 = (bool) true ;
10750 wxImage *result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "width",(char *) "height",(char *) "clear", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 if (obj0) {
10760 {
10761 arg1 = (int)(SWIG_As_int(obj0));
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 }
10764 }
10765 if (obj1) {
10766 {
10767 arg2 = (int)(SWIG_As_int(obj1));
10768 if (SWIG_arg_fail(2)) SWIG_fail;
10769 }
10770 }
10771 if (obj2) {
10772 {
10773 arg3 = (bool)(SWIG_As_bool(obj2));
10774 if (SWIG_arg_fail(3)) SWIG_fail;
10775 }
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj;
10793 wxBitmap *arg1 = 0 ;
10794 wxImage *result;
10795 PyObject * obj0 = 0 ;
10796 char *kwnames[] = {
10797 (char *) "bitmap", NULL
10798 };
10799
10800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10801 {
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 if (arg1 == NULL) {
10805 SWIG_null_ref("wxBitmap");
10806 }
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 }
10809 {
10810 if (!wxPyCheckForApp()) SWIG_fail;
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 int arg1 ;
10827 int arg2 ;
10828 unsigned char *arg3 = (unsigned char *) 0 ;
10829 wxImage *result;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 PyObject * obj2 = 0 ;
10833 char *kwnames[] = {
10834 (char *) "width",(char *) "height",(char *) "data", NULL
10835 };
10836
10837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10838 {
10839 arg1 = (int)(SWIG_As_int(obj0));
10840 if (SWIG_arg_fail(1)) SWIG_fail;
10841 }
10842 {
10843 arg2 = (int)(SWIG_As_int(obj1));
10844 if (SWIG_arg_fail(2)) SWIG_fail;
10845 }
10846 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(3)) SWIG_fail;
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10851
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj;
10864 int arg1 ;
10865 int arg2 ;
10866 unsigned char *arg3 = (unsigned char *) 0 ;
10867 unsigned char *arg4 = (unsigned char *) 0 ;
10868 wxImage *result;
10869 PyObject * obj0 = 0 ;
10870 PyObject * obj1 = 0 ;
10871 PyObject * obj2 = 0 ;
10872 PyObject * obj3 = 0 ;
10873 char *kwnames[] = {
10874 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10875 };
10876
10877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10878 {
10879 arg1 = (int)(SWIG_As_int(obj0));
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 }
10882 {
10883 arg2 = (int)(SWIG_As_int(obj1));
10884 if (SWIG_arg_fail(2)) SWIG_fail;
10885 }
10886 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10887 if (SWIG_arg_fail(3)) SWIG_fail;
10888 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10889 if (SWIG_arg_fail(4)) SWIG_fail;
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10893
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj;
10906 wxImage *arg1 = (wxImage *) 0 ;
10907 int arg2 ;
10908 int arg3 ;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 char *kwnames[] = {
10913 (char *) "self",(char *) "width",(char *) "height", NULL
10914 };
10915
10916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10918 if (SWIG_arg_fail(1)) SWIG_fail;
10919 {
10920 arg2 = (int)(SWIG_As_int(obj1));
10921 if (SWIG_arg_fail(2)) SWIG_fail;
10922 }
10923 {
10924 arg3 = (int)(SWIG_As_int(obj2));
10925 if (SWIG_arg_fail(3)) SWIG_fail;
10926 }
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->Create(arg2,arg3);
10930
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 Py_INCREF(Py_None); resultobj = Py_None;
10935 return resultobj;
10936 fail:
10937 return NULL;
10938 }
10939
10940
10941 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj;
10943 wxImage *arg1 = (wxImage *) 0 ;
10944 PyObject * obj0 = 0 ;
10945 char *kwnames[] = {
10946 (char *) "self", NULL
10947 };
10948
10949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10951 if (SWIG_arg_fail(1)) SWIG_fail;
10952 {
10953 PyThreadState* __tstate = wxPyBeginAllowThreads();
10954 (arg1)->Destroy();
10955
10956 wxPyEndAllowThreads(__tstate);
10957 if (PyErr_Occurred()) SWIG_fail;
10958 }
10959 Py_INCREF(Py_None); resultobj = Py_None;
10960 return resultobj;
10961 fail:
10962 return NULL;
10963 }
10964
10965
10966 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10967 PyObject *resultobj;
10968 wxImage *arg1 = (wxImage *) 0 ;
10969 int arg2 ;
10970 int arg3 ;
10971 SwigValueWrapper<wxImage > result;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 PyObject * obj2 = 0 ;
10975 char *kwnames[] = {
10976 (char *) "self",(char *) "width",(char *) "height", NULL
10977 };
10978
10979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10981 if (SWIG_arg_fail(1)) SWIG_fail;
10982 {
10983 arg2 = (int)(SWIG_As_int(obj1));
10984 if (SWIG_arg_fail(2)) SWIG_fail;
10985 }
10986 {
10987 arg3 = (int)(SWIG_As_int(obj2));
10988 if (SWIG_arg_fail(3)) SWIG_fail;
10989 }
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (arg1)->Scale(arg2,arg3);
10993
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 wxImage * resultptr;
10999 resultptr = new wxImage((wxImage &)(result));
11000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11001 }
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj;
11010 wxImage *arg1 = (wxImage *) 0 ;
11011 int arg2 ;
11012 int arg3 ;
11013 SwigValueWrapper<wxImage > result;
11014 PyObject * obj0 = 0 ;
11015 PyObject * obj1 = 0 ;
11016 PyObject * obj2 = 0 ;
11017 char *kwnames[] = {
11018 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11019 };
11020
11021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11023 if (SWIG_arg_fail(1)) SWIG_fail;
11024 {
11025 arg2 = (int)(SWIG_As_int(obj1));
11026 if (SWIG_arg_fail(2)) SWIG_fail;
11027 }
11028 {
11029 arg3 = (int)(SWIG_As_int(obj2));
11030 if (SWIG_arg_fail(3)) SWIG_fail;
11031 }
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11035
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 wxImage * resultptr;
11041 resultptr = new wxImage((wxImage &)(result));
11042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11043 }
11044 return resultobj;
11045 fail:
11046 return NULL;
11047 }
11048
11049
11050 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11051 PyObject *resultobj;
11052 wxImage *arg1 = (wxImage *) 0 ;
11053 int arg2 ;
11054 int arg3 ;
11055 wxImage *result;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self",(char *) "width",(char *) "height", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 arg2 = (int)(SWIG_As_int(obj1));
11068 if (SWIG_arg_fail(2)) SWIG_fail;
11069 }
11070 {
11071 arg3 = (int)(SWIG_As_int(obj2));
11072 if (SWIG_arg_fail(3)) SWIG_fail;
11073 }
11074 {
11075 PyThreadState* __tstate = wxPyBeginAllowThreads();
11076 {
11077 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11078 result = (wxImage *) &_result_ref;
11079 }
11080
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj;
11093 wxImage *arg1 = (wxImage *) 0 ;
11094 wxSize *arg2 = 0 ;
11095 wxPoint *arg3 = 0 ;
11096 int arg4 = (int) -1 ;
11097 int arg5 = (int) -1 ;
11098 int arg6 = (int) -1 ;
11099 wxImage *result;
11100 wxSize temp2 ;
11101 wxPoint temp3 ;
11102 PyObject * obj0 = 0 ;
11103 PyObject * obj1 = 0 ;
11104 PyObject * obj2 = 0 ;
11105 PyObject * obj3 = 0 ;
11106 PyObject * obj4 = 0 ;
11107 PyObject * obj5 = 0 ;
11108 char *kwnames[] = {
11109 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11110 };
11111
11112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11114 if (SWIG_arg_fail(1)) SWIG_fail;
11115 {
11116 arg2 = &temp2;
11117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11118 }
11119 {
11120 arg3 = &temp3;
11121 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11122 }
11123 if (obj3) {
11124 {
11125 arg4 = (int)(SWIG_As_int(obj3));
11126 if (SWIG_arg_fail(4)) SWIG_fail;
11127 }
11128 }
11129 if (obj4) {
11130 {
11131 arg5 = (int)(SWIG_As_int(obj4));
11132 if (SWIG_arg_fail(5)) SWIG_fail;
11133 }
11134 }
11135 if (obj5) {
11136 {
11137 arg6 = (int)(SWIG_As_int(obj5));
11138 if (SWIG_arg_fail(6)) SWIG_fail;
11139 }
11140 }
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 {
11144 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11145 result = (wxImage *) &_result_ref;
11146 }
11147
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj;
11160 wxImage *arg1 = (wxImage *) 0 ;
11161 int arg2 ;
11162 int arg3 ;
11163 unsigned char arg4 ;
11164 unsigned char arg5 ;
11165 unsigned char arg6 ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 PyObject * obj2 = 0 ;
11169 PyObject * obj3 = 0 ;
11170 PyObject * obj4 = 0 ;
11171 PyObject * obj5 = 0 ;
11172 char *kwnames[] = {
11173 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11174 };
11175
11176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11178 if (SWIG_arg_fail(1)) SWIG_fail;
11179 {
11180 arg2 = (int)(SWIG_As_int(obj1));
11181 if (SWIG_arg_fail(2)) SWIG_fail;
11182 }
11183 {
11184 arg3 = (int)(SWIG_As_int(obj2));
11185 if (SWIG_arg_fail(3)) SWIG_fail;
11186 }
11187 {
11188 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11189 if (SWIG_arg_fail(4)) SWIG_fail;
11190 }
11191 {
11192 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11193 if (SWIG_arg_fail(5)) SWIG_fail;
11194 }
11195 {
11196 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11197 if (SWIG_arg_fail(6)) SWIG_fail;
11198 }
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 Py_INCREF(Py_None); resultobj = Py_None;
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxImage *arg1 = (wxImage *) 0 ;
11216 wxRect *arg2 = 0 ;
11217 unsigned char arg3 ;
11218 unsigned char arg4 ;
11219 unsigned char arg5 ;
11220 wxRect temp2 ;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 PyObject * obj3 = 0 ;
11225 PyObject * obj4 = 0 ;
11226 char *kwnames[] = {
11227 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11228 };
11229
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 {
11234 arg2 = &temp2;
11235 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11236 }
11237 {
11238 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11239 if (SWIG_arg_fail(3)) SWIG_fail;
11240 }
11241 {
11242 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11243 if (SWIG_arg_fail(4)) SWIG_fail;
11244 }
11245 {
11246 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11247 if (SWIG_arg_fail(5)) SWIG_fail;
11248 }
11249 {
11250 PyThreadState* __tstate = wxPyBeginAllowThreads();
11251 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11252
11253 wxPyEndAllowThreads(__tstate);
11254 if (PyErr_Occurred()) SWIG_fail;
11255 }
11256 Py_INCREF(Py_None); resultobj = Py_None;
11257 return resultobj;
11258 fail:
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj;
11265 wxImage *arg1 = (wxImage *) 0 ;
11266 int arg2 ;
11267 int arg3 ;
11268 unsigned char result;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 PyObject * obj2 = 0 ;
11272 char *kwnames[] = {
11273 (char *) "self",(char *) "x",(char *) "y", NULL
11274 };
11275
11276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11278 if (SWIG_arg_fail(1)) SWIG_fail;
11279 {
11280 arg2 = (int)(SWIG_As_int(obj1));
11281 if (SWIG_arg_fail(2)) SWIG_fail;
11282 }
11283 {
11284 arg3 = (int)(SWIG_As_int(obj2));
11285 if (SWIG_arg_fail(3)) SWIG_fail;
11286 }
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11290
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 {
11295 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11296 }
11297 return resultobj;
11298 fail:
11299 return NULL;
11300 }
11301
11302
11303 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11304 PyObject *resultobj;
11305 wxImage *arg1 = (wxImage *) 0 ;
11306 int arg2 ;
11307 int arg3 ;
11308 unsigned char result;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 PyObject * obj2 = 0 ;
11312 char *kwnames[] = {
11313 (char *) "self",(char *) "x",(char *) "y", NULL
11314 };
11315
11316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11318 if (SWIG_arg_fail(1)) SWIG_fail;
11319 {
11320 arg2 = (int)(SWIG_As_int(obj1));
11321 if (SWIG_arg_fail(2)) SWIG_fail;
11322 }
11323 {
11324 arg3 = (int)(SWIG_As_int(obj2));
11325 if (SWIG_arg_fail(3)) SWIG_fail;
11326 }
11327 {
11328 PyThreadState* __tstate = wxPyBeginAllowThreads();
11329 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11330
11331 wxPyEndAllowThreads(__tstate);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 }
11334 {
11335 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11336 }
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj;
11345 wxImage *arg1 = (wxImage *) 0 ;
11346 int arg2 ;
11347 int arg3 ;
11348 unsigned char result;
11349 PyObject * obj0 = 0 ;
11350 PyObject * obj1 = 0 ;
11351 PyObject * obj2 = 0 ;
11352 char *kwnames[] = {
11353 (char *) "self",(char *) "x",(char *) "y", NULL
11354 };
11355
11356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11358 if (SWIG_arg_fail(1)) SWIG_fail;
11359 {
11360 arg2 = (int)(SWIG_As_int(obj1));
11361 if (SWIG_arg_fail(2)) SWIG_fail;
11362 }
11363 {
11364 arg3 = (int)(SWIG_As_int(obj2));
11365 if (SWIG_arg_fail(3)) SWIG_fail;
11366 }
11367 {
11368 PyThreadState* __tstate = wxPyBeginAllowThreads();
11369 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11370
11371 wxPyEndAllowThreads(__tstate);
11372 if (PyErr_Occurred()) SWIG_fail;
11373 }
11374 {
11375 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11376 }
11377 return resultobj;
11378 fail:
11379 return NULL;
11380 }
11381
11382
11383 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj;
11385 wxImage *arg1 = (wxImage *) 0 ;
11386 int arg2 ;
11387 int arg3 ;
11388 unsigned char arg4 ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 PyObject * obj2 = 0 ;
11392 PyObject * obj3 = 0 ;
11393 char *kwnames[] = {
11394 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11395 };
11396
11397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11399 if (SWIG_arg_fail(1)) SWIG_fail;
11400 {
11401 arg2 = (int)(SWIG_As_int(obj1));
11402 if (SWIG_arg_fail(2)) SWIG_fail;
11403 }
11404 {
11405 arg3 = (int)(SWIG_As_int(obj2));
11406 if (SWIG_arg_fail(3)) SWIG_fail;
11407 }
11408 {
11409 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11410 if (SWIG_arg_fail(4)) SWIG_fail;
11411 }
11412 {
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 (arg1)->SetAlpha(arg2,arg3,arg4);
11415
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 Py_INCREF(Py_None); resultobj = Py_None;
11420 return resultobj;
11421 fail:
11422 return NULL;
11423 }
11424
11425
11426 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11427 PyObject *resultobj;
11428 wxImage *arg1 = (wxImage *) 0 ;
11429 int arg2 ;
11430 int arg3 ;
11431 unsigned char result;
11432 PyObject * obj0 = 0 ;
11433 PyObject * obj1 = 0 ;
11434 PyObject * obj2 = 0 ;
11435 char *kwnames[] = {
11436 (char *) "self",(char *) "x",(char *) "y", NULL
11437 };
11438
11439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11441 if (SWIG_arg_fail(1)) SWIG_fail;
11442 {
11443 arg2 = (int)(SWIG_As_int(obj1));
11444 if (SWIG_arg_fail(2)) SWIG_fail;
11445 }
11446 {
11447 arg3 = (int)(SWIG_As_int(obj2));
11448 if (SWIG_arg_fail(3)) SWIG_fail;
11449 }
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11453
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 {
11458 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11459 }
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj;
11468 wxImage *arg1 = (wxImage *) 0 ;
11469 bool result;
11470 PyObject * obj0 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "self", NULL
11473 };
11474
11475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11477 if (SWIG_arg_fail(1)) SWIG_fail;
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 result = (bool)(arg1)->HasAlpha();
11481
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 {
11486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11487 }
11488 return resultobj;
11489 fail:
11490 return NULL;
11491 }
11492
11493
11494 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11495 PyObject *resultobj;
11496 wxImage *arg1 = (wxImage *) 0 ;
11497 PyObject * obj0 = 0 ;
11498 char *kwnames[] = {
11499 (char *) "self", NULL
11500 };
11501
11502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11504 if (SWIG_arg_fail(1)) SWIG_fail;
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 (arg1)->InitAlpha();
11508
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 Py_INCREF(Py_None); resultobj = Py_None;
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj;
11521 wxImage *arg1 = (wxImage *) 0 ;
11522 byte *arg2 = (byte *) 0 ;
11523 byte *arg3 = (byte *) 0 ;
11524 byte *arg4 = (byte *) 0 ;
11525 byte arg5 = (byte) 0 ;
11526 byte arg6 = (byte) 0 ;
11527 byte arg7 = (byte) 0 ;
11528 bool result;
11529 byte temp2 ;
11530 int res2 = 0 ;
11531 byte temp3 ;
11532 int res3 = 0 ;
11533 byte temp4 ;
11534 int res4 = 0 ;
11535 PyObject * obj0 = 0 ;
11536 PyObject * obj1 = 0 ;
11537 PyObject * obj2 = 0 ;
11538 PyObject * obj3 = 0 ;
11539 char *kwnames[] = {
11540 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11541 };
11542
11543 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11544 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11545 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11548 if (SWIG_arg_fail(1)) SWIG_fail;
11549 if (obj1) {
11550 {
11551 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11552 if (SWIG_arg_fail(5)) SWIG_fail;
11553 }
11554 }
11555 if (obj2) {
11556 {
11557 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11558 if (SWIG_arg_fail(6)) SWIG_fail;
11559 }
11560 }
11561 if (obj3) {
11562 {
11563 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11564 if (SWIG_arg_fail(7)) SWIG_fail;
11565 }
11566 }
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11576 }
11577 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11578 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11579 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11580 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11581 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11582 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj;
11591 wxImage *arg1 = (wxImage *) 0 ;
11592 byte arg2 = (byte) 128 ;
11593 bool result;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self",(char *) "threshold", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 if (obj1) {
11604 {
11605 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11606 if (SWIG_arg_fail(2)) SWIG_fail;
11607 }
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11612
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11618 }
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxImage *arg1 = (wxImage *) 0 ;
11628 unsigned char arg2 ;
11629 unsigned char arg3 ;
11630 unsigned char arg4 ;
11631 bool result;
11632 PyObject * obj0 = 0 ;
11633 PyObject * obj1 = 0 ;
11634 PyObject * obj2 = 0 ;
11635 PyObject * obj3 = 0 ;
11636 char *kwnames[] = {
11637 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11638 };
11639
11640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11642 if (SWIG_arg_fail(1)) SWIG_fail;
11643 {
11644 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11645 if (SWIG_arg_fail(2)) SWIG_fail;
11646 }
11647 {
11648 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11649 if (SWIG_arg_fail(3)) SWIG_fail;
11650 }
11651 {
11652 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11653 if (SWIG_arg_fail(4)) SWIG_fail;
11654 }
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11658
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 {
11663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11664 }
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj;
11673 wxImage *arg1 = (wxImage *) 0 ;
11674 wxImage *arg2 = 0 ;
11675 byte arg3 ;
11676 byte arg4 ;
11677 byte arg5 ;
11678 bool result;
11679 PyObject * obj0 = 0 ;
11680 PyObject * obj1 = 0 ;
11681 PyObject * obj2 = 0 ;
11682 PyObject * obj3 = 0 ;
11683 PyObject * obj4 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11693 if (SWIG_arg_fail(2)) SWIG_fail;
11694 if (arg2 == NULL) {
11695 SWIG_null_ref("wxImage");
11696 }
11697 if (SWIG_arg_fail(2)) SWIG_fail;
11698 }
11699 {
11700 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11701 if (SWIG_arg_fail(3)) SWIG_fail;
11702 }
11703 {
11704 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11705 if (SWIG_arg_fail(4)) SWIG_fail;
11706 }
11707 {
11708 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11709 if (SWIG_arg_fail(5)) SWIG_fail;
11710 }
11711 {
11712 PyThreadState* __tstate = wxPyBeginAllowThreads();
11713 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11714
11715 wxPyEndAllowThreads(__tstate);
11716 if (PyErr_Occurred()) SWIG_fail;
11717 }
11718 {
11719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11728 PyObject *resultobj;
11729 wxString *arg1 = 0 ;
11730 bool result;
11731 bool temp1 = false ;
11732 PyObject * obj0 = 0 ;
11733 char *kwnames[] = {
11734 (char *) "name", NULL
11735 };
11736
11737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11738 {
11739 arg1 = wxString_in_helper(obj0);
11740 if (arg1 == NULL) SWIG_fail;
11741 temp1 = true;
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp1)
11755 delete arg1;
11756 }
11757 return resultobj;
11758 fail:
11759 {
11760 if (temp1)
11761 delete arg1;
11762 }
11763 return NULL;
11764 }
11765
11766
11767 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11768 PyObject *resultobj;
11769 wxString *arg1 = 0 ;
11770 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11771 int result;
11772 bool temp1 = false ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 char *kwnames[] = {
11776 (char *) "name",(char *) "type", NULL
11777 };
11778
11779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11780 {
11781 arg1 = wxString_in_helper(obj0);
11782 if (arg1 == NULL) SWIG_fail;
11783 temp1 = true;
11784 }
11785 if (obj1) {
11786 {
11787 arg2 = (long)(SWIG_As_long(obj1));
11788 if (SWIG_arg_fail(2)) SWIG_fail;
11789 }
11790 }
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11794
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 resultobj = SWIG_From_int((int)(result));
11800 }
11801 {
11802 if (temp1)
11803 delete arg1;
11804 }
11805 return resultobj;
11806 fail:
11807 {
11808 if (temp1)
11809 delete arg1;
11810 }
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj;
11817 wxImage *arg1 = (wxImage *) 0 ;
11818 wxString *arg2 = 0 ;
11819 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11820 int arg4 = (int) -1 ;
11821 bool result;
11822 bool temp2 = false ;
11823 PyObject * obj0 = 0 ;
11824 PyObject * obj1 = 0 ;
11825 PyObject * obj2 = 0 ;
11826 PyObject * obj3 = 0 ;
11827 char *kwnames[] = {
11828 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11829 };
11830
11831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11833 if (SWIG_arg_fail(1)) SWIG_fail;
11834 {
11835 arg2 = wxString_in_helper(obj1);
11836 if (arg2 == NULL) SWIG_fail;
11837 temp2 = true;
11838 }
11839 if (obj2) {
11840 {
11841 arg3 = (long)(SWIG_As_long(obj2));
11842 if (SWIG_arg_fail(3)) SWIG_fail;
11843 }
11844 }
11845 if (obj3) {
11846 {
11847 arg4 = (int)(SWIG_As_int(obj3));
11848 if (SWIG_arg_fail(4)) SWIG_fail;
11849 }
11850 }
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11854
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 {
11859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11860 }
11861 {
11862 if (temp2)
11863 delete arg2;
11864 }
11865 return resultobj;
11866 fail:
11867 {
11868 if (temp2)
11869 delete arg2;
11870 }
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxImage *arg1 = (wxImage *) 0 ;
11878 wxString *arg2 = 0 ;
11879 wxString *arg3 = 0 ;
11880 int arg4 = (int) -1 ;
11881 bool result;
11882 bool temp2 = false ;
11883 bool temp3 = false ;
11884 PyObject * obj0 = 0 ;
11885 PyObject * obj1 = 0 ;
11886 PyObject * obj2 = 0 ;
11887 PyObject * obj3 = 0 ;
11888 char *kwnames[] = {
11889 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11890 };
11891
11892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11894 if (SWIG_arg_fail(1)) SWIG_fail;
11895 {
11896 arg2 = wxString_in_helper(obj1);
11897 if (arg2 == NULL) SWIG_fail;
11898 temp2 = true;
11899 }
11900 {
11901 arg3 = wxString_in_helper(obj2);
11902 if (arg3 == NULL) SWIG_fail;
11903 temp3 = true;
11904 }
11905 if (obj3) {
11906 {
11907 arg4 = (int)(SWIG_As_int(obj3));
11908 if (SWIG_arg_fail(4)) SWIG_fail;
11909 }
11910 }
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11914
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 {
11919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11920 }
11921 {
11922 if (temp2)
11923 delete arg2;
11924 }
11925 {
11926 if (temp3)
11927 delete arg3;
11928 }
11929 return resultobj;
11930 fail:
11931 {
11932 if (temp2)
11933 delete arg2;
11934 }
11935 {
11936 if (temp3)
11937 delete arg3;
11938 }
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxImage *arg1 = (wxImage *) 0 ;
11946 wxString *arg2 = 0 ;
11947 int arg3 ;
11948 bool result;
11949 bool temp2 = false ;
11950 PyObject * obj0 = 0 ;
11951 PyObject * obj1 = 0 ;
11952 PyObject * obj2 = 0 ;
11953 char *kwnames[] = {
11954 (char *) "self",(char *) "name",(char *) "type", NULL
11955 };
11956
11957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11959 if (SWIG_arg_fail(1)) SWIG_fail;
11960 {
11961 arg2 = wxString_in_helper(obj1);
11962 if (arg2 == NULL) SWIG_fail;
11963 temp2 = true;
11964 }
11965 {
11966 arg3 = (int)(SWIG_As_int(obj2));
11967 if (SWIG_arg_fail(3)) SWIG_fail;
11968 }
11969 {
11970 PyThreadState* __tstate = wxPyBeginAllowThreads();
11971 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11972
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 {
11977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11978 }
11979 {
11980 if (temp2)
11981 delete arg2;
11982 }
11983 return resultobj;
11984 fail:
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxImage *arg1 = (wxImage *) 0 ;
11996 wxString *arg2 = 0 ;
11997 wxString *arg3 = 0 ;
11998 bool result;
11999 bool temp2 = false ;
12000 bool temp3 = false ;
12001 PyObject * obj0 = 0 ;
12002 PyObject * obj1 = 0 ;
12003 PyObject * obj2 = 0 ;
12004 char *kwnames[] = {
12005 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12006 };
12007
12008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12010 if (SWIG_arg_fail(1)) SWIG_fail;
12011 {
12012 arg2 = wxString_in_helper(obj1);
12013 if (arg2 == NULL) SWIG_fail;
12014 temp2 = true;
12015 }
12016 {
12017 arg3 = wxString_in_helper(obj2);
12018 if (arg3 == NULL) SWIG_fail;
12019 temp3 = true;
12020 }
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12030 }
12031 {
12032 if (temp2)
12033 delete arg2;
12034 }
12035 {
12036 if (temp3)
12037 delete arg3;
12038 }
12039 return resultobj;
12040 fail:
12041 {
12042 if (temp2)
12043 delete arg2;
12044 }
12045 {
12046 if (temp3)
12047 delete arg3;
12048 }
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxInputStream *arg1 = 0 ;
12056 bool result;
12057 wxPyInputStream *temp1 ;
12058 bool created1 ;
12059 PyObject * obj0 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "stream", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12065 {
12066 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12067 arg1 = temp1->m_wxis;
12068 created1 = false;
12069 } else {
12070 PyErr_Clear(); // clear the failure of the wxPyConvert above
12071 arg1 = wxPyCBInputStream_create(obj0, false);
12072 if (arg1 == NULL) {
12073 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12074 SWIG_fail;
12075 }
12076 created1 = true;
12077 }
12078 }
12079 {
12080 PyThreadState* __tstate = wxPyBeginAllowThreads();
12081 result = (bool)wxImage::CanRead(*arg1);
12082
12083 wxPyEndAllowThreads(__tstate);
12084 if (PyErr_Occurred()) SWIG_fail;
12085 }
12086 {
12087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12088 }
12089 {
12090 if (created1) delete arg1;
12091 }
12092 return resultobj;
12093 fail:
12094 {
12095 if (created1) delete arg1;
12096 }
12097 return NULL;
12098 }
12099
12100
12101 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj;
12103 wxImage *arg1 = (wxImage *) 0 ;
12104 wxInputStream *arg2 = 0 ;
12105 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12106 int arg4 = (int) -1 ;
12107 bool result;
12108 wxPyInputStream *temp2 ;
12109 bool created2 ;
12110 PyObject * obj0 = 0 ;
12111 PyObject * obj1 = 0 ;
12112 PyObject * obj2 = 0 ;
12113 PyObject * obj3 = 0 ;
12114 char *kwnames[] = {
12115 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12116 };
12117
12118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12120 if (SWIG_arg_fail(1)) SWIG_fail;
12121 {
12122 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12123 arg2 = temp2->m_wxis;
12124 created2 = false;
12125 } else {
12126 PyErr_Clear(); // clear the failure of the wxPyConvert above
12127 arg2 = wxPyCBInputStream_create(obj1, false);
12128 if (arg2 == NULL) {
12129 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12130 SWIG_fail;
12131 }
12132 created2 = true;
12133 }
12134 }
12135 if (obj2) {
12136 {
12137 arg3 = (long)(SWIG_As_long(obj2));
12138 if (SWIG_arg_fail(3)) SWIG_fail;
12139 }
12140 }
12141 if (obj3) {
12142 {
12143 arg4 = (int)(SWIG_As_int(obj3));
12144 if (SWIG_arg_fail(4)) SWIG_fail;
12145 }
12146 }
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 {
12155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12156 }
12157 {
12158 if (created2) delete arg2;
12159 }
12160 return resultobj;
12161 fail:
12162 {
12163 if (created2) delete arg2;
12164 }
12165 return NULL;
12166 }
12167
12168
12169 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj;
12171 wxImage *arg1 = (wxImage *) 0 ;
12172 wxInputStream *arg2 = 0 ;
12173 wxString *arg3 = 0 ;
12174 int arg4 = (int) -1 ;
12175 bool result;
12176 wxPyInputStream *temp2 ;
12177 bool created2 ;
12178 bool temp3 = false ;
12179 PyObject * obj0 = 0 ;
12180 PyObject * obj1 = 0 ;
12181 PyObject * obj2 = 0 ;
12182 PyObject * obj3 = 0 ;
12183 char *kwnames[] = {
12184 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12185 };
12186
12187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12189 if (SWIG_arg_fail(1)) SWIG_fail;
12190 {
12191 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12192 arg2 = temp2->m_wxis;
12193 created2 = false;
12194 } else {
12195 PyErr_Clear(); // clear the failure of the wxPyConvert above
12196 arg2 = wxPyCBInputStream_create(obj1, false);
12197 if (arg2 == NULL) {
12198 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12199 SWIG_fail;
12200 }
12201 created2 = true;
12202 }
12203 }
12204 {
12205 arg3 = wxString_in_helper(obj2);
12206 if (arg3 == NULL) SWIG_fail;
12207 temp3 = true;
12208 }
12209 if (obj3) {
12210 {
12211 arg4 = (int)(SWIG_As_int(obj3));
12212 if (SWIG_arg_fail(4)) SWIG_fail;
12213 }
12214 }
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12224 }
12225 {
12226 if (created2) delete arg2;
12227 }
12228 {
12229 if (temp3)
12230 delete arg3;
12231 }
12232 return resultobj;
12233 fail:
12234 {
12235 if (created2) delete arg2;
12236 }
12237 {
12238 if (temp3)
12239 delete arg3;
12240 }
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxImage *arg1 = (wxImage *) 0 ;
12248 bool result;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (bool)(arg1)->Ok();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12266 }
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxImage *arg1 = (wxImage *) 0 ;
12276 int result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->GetWidth();
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = SWIG_From_int((int)(result));
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxImage *arg1 = (wxImage *) 0 ;
12304 int result;
12305 PyObject * obj0 = 0 ;
12306 char *kwnames[] = {
12307 (char *) "self", NULL
12308 };
12309
12310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12312 if (SWIG_arg_fail(1)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (int)(arg1)->GetHeight();
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = SWIG_From_int((int)(result));
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxImage *arg1 = (wxImage *) 0 ;
12332 wxSize result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = wxImage_GetSize(arg1);
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 wxSize * resultptr;
12350 resultptr = new wxSize((wxSize &)(result));
12351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj;
12361 wxImage *arg1 = (wxImage *) 0 ;
12362 wxRect *arg2 = 0 ;
12363 SwigValueWrapper<wxImage > result;
12364 wxRect temp2 ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 char *kwnames[] = {
12368 (char *) "self",(char *) "rect", NULL
12369 };
12370
12371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12373 if (SWIG_arg_fail(1)) SWIG_fail;
12374 {
12375 arg2 = &temp2;
12376 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12377 }
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12381
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 {
12386 wxImage * resultptr;
12387 resultptr = new wxImage((wxImage &)(result));
12388 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12389 }
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj;
12398 wxImage *arg1 = (wxImage *) 0 ;
12399 wxSize *arg2 = 0 ;
12400 wxPoint *arg3 = 0 ;
12401 int arg4 = (int) -1 ;
12402 int arg5 = (int) -1 ;
12403 int arg6 = (int) -1 ;
12404 SwigValueWrapper<wxImage > result;
12405 wxSize temp2 ;
12406 wxPoint temp3 ;
12407 PyObject * obj0 = 0 ;
12408 PyObject * obj1 = 0 ;
12409 PyObject * obj2 = 0 ;
12410 PyObject * obj3 = 0 ;
12411 PyObject * obj4 = 0 ;
12412 PyObject * obj5 = 0 ;
12413 char *kwnames[] = {
12414 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12415 };
12416
12417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12419 if (SWIG_arg_fail(1)) SWIG_fail;
12420 {
12421 arg2 = &temp2;
12422 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12423 }
12424 {
12425 arg3 = &temp3;
12426 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12427 }
12428 if (obj3) {
12429 {
12430 arg4 = (int)(SWIG_As_int(obj3));
12431 if (SWIG_arg_fail(4)) SWIG_fail;
12432 }
12433 }
12434 if (obj4) {
12435 {
12436 arg5 = (int)(SWIG_As_int(obj4));
12437 if (SWIG_arg_fail(5)) SWIG_fail;
12438 }
12439 }
12440 if (obj5) {
12441 {
12442 arg6 = (int)(SWIG_As_int(obj5));
12443 if (SWIG_arg_fail(6)) SWIG_fail;
12444 }
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 wxImage * resultptr;
12455 resultptr = new wxImage((wxImage &)(result));
12456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj;
12466 wxImage *arg1 = (wxImage *) 0 ;
12467 SwigValueWrapper<wxImage > result;
12468 PyObject * obj0 = 0 ;
12469 char *kwnames[] = {
12470 (char *) "self", NULL
12471 };
12472
12473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12475 if (SWIG_arg_fail(1)) SWIG_fail;
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 result = (arg1)->Copy();
12479
12480 wxPyEndAllowThreads(__tstate);
12481 if (PyErr_Occurred()) SWIG_fail;
12482 }
12483 {
12484 wxImage * resultptr;
12485 resultptr = new wxImage((wxImage &)(result));
12486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12487 }
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12495 PyObject *resultobj;
12496 wxImage *arg1 = (wxImage *) 0 ;
12497 wxImage *arg2 = 0 ;
12498 int arg3 ;
12499 int arg4 ;
12500 PyObject * obj0 = 0 ;
12501 PyObject * obj1 = 0 ;
12502 PyObject * obj2 = 0 ;
12503 PyObject * obj3 = 0 ;
12504 char *kwnames[] = {
12505 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12506 };
12507
12508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12510 if (SWIG_arg_fail(1)) SWIG_fail;
12511 {
12512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12513 if (SWIG_arg_fail(2)) SWIG_fail;
12514 if (arg2 == NULL) {
12515 SWIG_null_ref("wxImage");
12516 }
12517 if (SWIG_arg_fail(2)) SWIG_fail;
12518 }
12519 {
12520 arg3 = (int)(SWIG_As_int(obj2));
12521 if (SWIG_arg_fail(3)) SWIG_fail;
12522 }
12523 {
12524 arg4 = (int)(SWIG_As_int(obj3));
12525 if (SWIG_arg_fail(4)) SWIG_fail;
12526 }
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 Py_INCREF(Py_None); resultobj = Py_None;
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxImage *arg1 = (wxImage *) 0 ;
12544 PyObject *result;
12545 PyObject * obj0 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (PyObject *)wxImage_GetData(arg1);
12556
12557 wxPyEndAllowThreads(__tstate);
12558 if (PyErr_Occurred()) SWIG_fail;
12559 }
12560 resultobj = result;
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxImage *arg1 = (wxImage *) 0 ;
12570 PyObject *arg2 = (PyObject *) 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 char *kwnames[] = {
12574 (char *) "self",(char *) "data", NULL
12575 };
12576
12577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12579 if (SWIG_arg_fail(1)) SWIG_fail;
12580 arg2 = obj1;
12581 {
12582 PyThreadState* __tstate = wxPyBeginAllowThreads();
12583 wxImage_SetData(arg1,arg2);
12584
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 Py_INCREF(Py_None); resultobj = Py_None;
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj;
12597 wxImage *arg1 = (wxImage *) 0 ;
12598 PyObject *result;
12599 PyObject * obj0 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 PyThreadState* __tstate = wxPyBeginAllowThreads();
12609 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12610
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 resultobj = result;
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj;
12623 wxImage *arg1 = (wxImage *) 0 ;
12624 PyObject *arg2 = (PyObject *) 0 ;
12625 PyObject * obj0 = 0 ;
12626 PyObject * obj1 = 0 ;
12627 char *kwnames[] = {
12628 (char *) "self",(char *) "data", NULL
12629 };
12630
12631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12633 if (SWIG_arg_fail(1)) SWIG_fail;
12634 arg2 = obj1;
12635 {
12636 PyThreadState* __tstate = wxPyBeginAllowThreads();
12637 wxImage_SetDataBuffer(arg1,arg2);
12638
12639 wxPyEndAllowThreads(__tstate);
12640 if (PyErr_Occurred()) SWIG_fail;
12641 }
12642 Py_INCREF(Py_None); resultobj = Py_None;
12643 return resultobj;
12644 fail:
12645 return NULL;
12646 }
12647
12648
12649 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12650 PyObject *resultobj;
12651 wxImage *arg1 = (wxImage *) 0 ;
12652 PyObject *result;
12653 PyObject * obj0 = 0 ;
12654 char *kwnames[] = {
12655 (char *) "self", NULL
12656 };
12657
12658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12660 if (SWIG_arg_fail(1)) SWIG_fail;
12661 {
12662 PyThreadState* __tstate = wxPyBeginAllowThreads();
12663 result = (PyObject *)wxImage_GetAlphaData(arg1);
12664
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 resultobj = result;
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj;
12677 wxImage *arg1 = (wxImage *) 0 ;
12678 PyObject *arg2 = (PyObject *) 0 ;
12679 PyObject * obj0 = 0 ;
12680 PyObject * obj1 = 0 ;
12681 char *kwnames[] = {
12682 (char *) "self",(char *) "data", NULL
12683 };
12684
12685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12687 if (SWIG_arg_fail(1)) SWIG_fail;
12688 arg2 = obj1;
12689 {
12690 PyThreadState* __tstate = wxPyBeginAllowThreads();
12691 wxImage_SetAlphaData(arg1,arg2);
12692
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 Py_INCREF(Py_None); resultobj = Py_None;
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxImage *arg1 = (wxImage *) 0 ;
12706 PyObject *result;
12707 PyObject * obj0 = 0 ;
12708 char *kwnames[] = {
12709 (char *) "self", NULL
12710 };
12711
12712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12714 if (SWIG_arg_fail(1)) SWIG_fail;
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12718
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 resultobj = result;
12723 return resultobj;
12724 fail:
12725 return NULL;
12726 }
12727
12728
12729 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12730 PyObject *resultobj;
12731 wxImage *arg1 = (wxImage *) 0 ;
12732 PyObject *arg2 = (PyObject *) 0 ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "self",(char *) "data", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12741 if (SWIG_arg_fail(1)) SWIG_fail;
12742 arg2 = obj1;
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 wxImage_SetAlphaBuffer(arg1,arg2);
12746
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 Py_INCREF(Py_None); resultobj = Py_None;
12751 return resultobj;
12752 fail:
12753 return NULL;
12754 }
12755
12756
12757 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12758 PyObject *resultobj;
12759 wxImage *arg1 = (wxImage *) 0 ;
12760 unsigned char arg2 ;
12761 unsigned char arg3 ;
12762 unsigned char arg4 ;
12763 PyObject * obj0 = 0 ;
12764 PyObject * obj1 = 0 ;
12765 PyObject * obj2 = 0 ;
12766 PyObject * obj3 = 0 ;
12767 char *kwnames[] = {
12768 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12769 };
12770
12771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12773 if (SWIG_arg_fail(1)) SWIG_fail;
12774 {
12775 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12776 if (SWIG_arg_fail(2)) SWIG_fail;
12777 }
12778 {
12779 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12780 if (SWIG_arg_fail(3)) SWIG_fail;
12781 }
12782 {
12783 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12784 if (SWIG_arg_fail(4)) SWIG_fail;
12785 }
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 (arg1)->SetMaskColour(arg2,arg3,arg4);
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 Py_INCREF(Py_None); resultobj = Py_None;
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj;
12802 wxImage *arg1 = (wxImage *) 0 ;
12803 unsigned char *arg2 = (unsigned char *) 0 ;
12804 unsigned char *arg3 = (unsigned char *) 0 ;
12805 unsigned char *arg4 = (unsigned char *) 0 ;
12806 unsigned char temp2 ;
12807 int res2 = 0 ;
12808 unsigned char temp3 ;
12809 int res3 = 0 ;
12810 unsigned char temp4 ;
12811 int res4 = 0 ;
12812 PyObject * obj0 = 0 ;
12813 char *kwnames[] = {
12814 (char *) "self", NULL
12815 };
12816
12817 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12818 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12819 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12826
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 Py_INCREF(Py_None); resultobj = Py_None;
12831 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12832 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12833 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12834 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12835 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12836 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj;
12845 wxImage *arg1 = (wxImage *) 0 ;
12846 unsigned char result;
12847 PyObject * obj0 = 0 ;
12848 char *kwnames[] = {
12849 (char *) "self", NULL
12850 };
12851
12852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",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 = (unsigned char)(arg1)->GetMaskRed();
12858
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 {
12863 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxImage *arg1 = (wxImage *) 0 ;
12874 unsigned char result;
12875 PyObject * obj0 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",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 = (unsigned char)(arg1)->GetMaskGreen();
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 {
12891 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12892 }
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj;
12901 wxImage *arg1 = (wxImage *) 0 ;
12902 unsigned char result;
12903 PyObject * obj0 = 0 ;
12904 char *kwnames[] = {
12905 (char *) "self", NULL
12906 };
12907
12908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12910 if (SWIG_arg_fail(1)) SWIG_fail;
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (unsigned char)(arg1)->GetMaskBlue();
12914
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 {
12919 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxImage *arg1 = (wxImage *) 0 ;
12930 bool arg2 = (bool) true ;
12931 PyObject * obj0 = 0 ;
12932 PyObject * obj1 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self",(char *) "mask", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12939 if (SWIG_arg_fail(1)) SWIG_fail;
12940 if (obj1) {
12941 {
12942 arg2 = (bool)(SWIG_As_bool(obj1));
12943 if (SWIG_arg_fail(2)) SWIG_fail;
12944 }
12945 }
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 (arg1)->SetMask(arg2);
12949
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 Py_INCREF(Py_None); resultobj = Py_None;
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12961 PyObject *resultobj;
12962 wxImage *arg1 = (wxImage *) 0 ;
12963 bool result;
12964 PyObject * obj0 = 0 ;
12965 char *kwnames[] = {
12966 (char *) "self", NULL
12967 };
12968
12969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12971 if (SWIG_arg_fail(1)) SWIG_fail;
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 result = (bool)(arg1)->HasMask();
12975
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 {
12980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12981 }
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12989 PyObject *resultobj;
12990 wxImage *arg1 = (wxImage *) 0 ;
12991 double arg2 ;
12992 wxPoint *arg3 = 0 ;
12993 bool arg4 = (bool) true ;
12994 wxPoint *arg5 = (wxPoint *) NULL ;
12995 SwigValueWrapper<wxImage > result;
12996 wxPoint temp3 ;
12997 PyObject * obj0 = 0 ;
12998 PyObject * obj1 = 0 ;
12999 PyObject * obj2 = 0 ;
13000 PyObject * obj3 = 0 ;
13001 PyObject * obj4 = 0 ;
13002 char *kwnames[] = {
13003 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13004 };
13005
13006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13008 if (SWIG_arg_fail(1)) SWIG_fail;
13009 {
13010 arg2 = (double)(SWIG_As_double(obj1));
13011 if (SWIG_arg_fail(2)) SWIG_fail;
13012 }
13013 {
13014 arg3 = &temp3;
13015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13016 }
13017 if (obj3) {
13018 {
13019 arg4 = (bool)(SWIG_As_bool(obj3));
13020 if (SWIG_arg_fail(4)) SWIG_fail;
13021 }
13022 }
13023 if (obj4) {
13024 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13025 if (SWIG_arg_fail(5)) SWIG_fail;
13026 }
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 wxImage * resultptr;
13036 resultptr = new wxImage((wxImage &)(result));
13037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13038 }
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxImage *arg1 = (wxImage *) 0 ;
13048 bool arg2 = (bool) true ;
13049 SwigValueWrapper<wxImage > result;
13050 PyObject * obj0 = 0 ;
13051 PyObject * obj1 = 0 ;
13052 char *kwnames[] = {
13053 (char *) "self",(char *) "clockwise", NULL
13054 };
13055
13056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13058 if (SWIG_arg_fail(1)) SWIG_fail;
13059 if (obj1) {
13060 {
13061 arg2 = (bool)(SWIG_As_bool(obj1));
13062 if (SWIG_arg_fail(2)) SWIG_fail;
13063 }
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (arg1)->Rotate90(arg2);
13068
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 {
13073 wxImage * resultptr;
13074 resultptr = new wxImage((wxImage &)(result));
13075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 bool arg2 = (bool) true ;
13087 SwigValueWrapper<wxImage > result;
13088 PyObject * obj0 = 0 ;
13089 PyObject * obj1 = 0 ;
13090 char *kwnames[] = {
13091 (char *) "self",(char *) "horizontally", NULL
13092 };
13093
13094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(1)) SWIG_fail;
13097 if (obj1) {
13098 {
13099 arg2 = (bool)(SWIG_As_bool(obj1));
13100 if (SWIG_arg_fail(2)) SWIG_fail;
13101 }
13102 }
13103 {
13104 PyThreadState* __tstate = wxPyBeginAllowThreads();
13105 result = (arg1)->Mirror(arg2);
13106
13107 wxPyEndAllowThreads(__tstate);
13108 if (PyErr_Occurred()) SWIG_fail;
13109 }
13110 {
13111 wxImage * resultptr;
13112 resultptr = new wxImage((wxImage &)(result));
13113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13114 }
13115 return resultobj;
13116 fail:
13117 return NULL;
13118 }
13119
13120
13121 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj;
13123 wxImage *arg1 = (wxImage *) 0 ;
13124 unsigned char arg2 ;
13125 unsigned char arg3 ;
13126 unsigned char arg4 ;
13127 unsigned char arg5 ;
13128 unsigned char arg6 ;
13129 unsigned char arg7 ;
13130 PyObject * obj0 = 0 ;
13131 PyObject * obj1 = 0 ;
13132 PyObject * obj2 = 0 ;
13133 PyObject * obj3 = 0 ;
13134 PyObject * obj4 = 0 ;
13135 PyObject * obj5 = 0 ;
13136 PyObject * obj6 = 0 ;
13137 char *kwnames[] = {
13138 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13139 };
13140
13141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13143 if (SWIG_arg_fail(1)) SWIG_fail;
13144 {
13145 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13146 if (SWIG_arg_fail(2)) SWIG_fail;
13147 }
13148 {
13149 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13150 if (SWIG_arg_fail(3)) SWIG_fail;
13151 }
13152 {
13153 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13154 if (SWIG_arg_fail(4)) SWIG_fail;
13155 }
13156 {
13157 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13158 if (SWIG_arg_fail(5)) SWIG_fail;
13159 }
13160 {
13161 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13162 if (SWIG_arg_fail(6)) SWIG_fail;
13163 }
13164 {
13165 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13166 if (SWIG_arg_fail(7)) SWIG_fail;
13167 }
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13171
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 Py_INCREF(Py_None); resultobj = Py_None;
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj;
13184 wxImage *arg1 = (wxImage *) 0 ;
13185 unsigned char arg2 ;
13186 unsigned char arg3 ;
13187 unsigned char arg4 ;
13188 SwigValueWrapper<wxImage > result;
13189 PyObject * obj0 = 0 ;
13190 PyObject * obj1 = 0 ;
13191 PyObject * obj2 = 0 ;
13192 PyObject * obj3 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13199 if (SWIG_arg_fail(1)) SWIG_fail;
13200 {
13201 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13202 if (SWIG_arg_fail(2)) SWIG_fail;
13203 }
13204 {
13205 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13206 if (SWIG_arg_fail(3)) SWIG_fail;
13207 }
13208 {
13209 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13210 if (SWIG_arg_fail(4)) SWIG_fail;
13211 }
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13215
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 {
13220 wxImage * resultptr;
13221 resultptr = new wxImage((wxImage &)(result));
13222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13223 }
13224 return resultobj;
13225 fail:
13226 return NULL;
13227 }
13228
13229
13230 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13231 PyObject *resultobj;
13232 wxImage *arg1 = (wxImage *) 0 ;
13233 wxString *arg2 = 0 ;
13234 wxString *arg3 = 0 ;
13235 bool temp2 = false ;
13236 bool temp3 = false ;
13237 PyObject * obj0 = 0 ;
13238 PyObject * obj1 = 0 ;
13239 PyObject * obj2 = 0 ;
13240 char *kwnames[] = {
13241 (char *) "self",(char *) "name",(char *) "value", NULL
13242 };
13243
13244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13246 if (SWIG_arg_fail(1)) SWIG_fail;
13247 {
13248 arg2 = wxString_in_helper(obj1);
13249 if (arg2 == NULL) SWIG_fail;
13250 temp2 = true;
13251 }
13252 {
13253 arg3 = wxString_in_helper(obj2);
13254 if (arg3 == NULL) SWIG_fail;
13255 temp3 = true;
13256 }
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 Py_INCREF(Py_None); resultobj = Py_None;
13265 {
13266 if (temp2)
13267 delete arg2;
13268 }
13269 {
13270 if (temp3)
13271 delete arg3;
13272 }
13273 return resultobj;
13274 fail:
13275 {
13276 if (temp2)
13277 delete arg2;
13278 }
13279 {
13280 if (temp3)
13281 delete arg3;
13282 }
13283 return NULL;
13284 }
13285
13286
13287 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13288 PyObject *resultobj;
13289 wxImage *arg1 = (wxImage *) 0 ;
13290 wxString *arg2 = 0 ;
13291 int arg3 ;
13292 bool temp2 = false ;
13293 PyObject * obj0 = 0 ;
13294 PyObject * obj1 = 0 ;
13295 PyObject * obj2 = 0 ;
13296 char *kwnames[] = {
13297 (char *) "self",(char *) "name",(char *) "value", NULL
13298 };
13299
13300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13302 if (SWIG_arg_fail(1)) SWIG_fail;
13303 {
13304 arg2 = wxString_in_helper(obj1);
13305 if (arg2 == NULL) SWIG_fail;
13306 temp2 = true;
13307 }
13308 {
13309 arg3 = (int)(SWIG_As_int(obj2));
13310 if (SWIG_arg_fail(3)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 (arg1)->SetOption((wxString const &)*arg2,arg3);
13315
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 Py_INCREF(Py_None); resultobj = Py_None;
13320 {
13321 if (temp2)
13322 delete arg2;
13323 }
13324 return resultobj;
13325 fail:
13326 {
13327 if (temp2)
13328 delete arg2;
13329 }
13330 return NULL;
13331 }
13332
13333
13334 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj;
13336 wxImage *arg1 = (wxImage *) 0 ;
13337 wxString *arg2 = 0 ;
13338 wxString result;
13339 bool temp2 = false ;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "name", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 {
13350 arg2 = wxString_in_helper(obj1);
13351 if (arg2 == NULL) SWIG_fail;
13352 temp2 = true;
13353 }
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13357
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 {
13362 #if wxUSE_UNICODE
13363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13364 #else
13365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13366 #endif
13367 }
13368 {
13369 if (temp2)
13370 delete arg2;
13371 }
13372 return resultobj;
13373 fail:
13374 {
13375 if (temp2)
13376 delete arg2;
13377 }
13378 return NULL;
13379 }
13380
13381
13382 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13383 PyObject *resultobj;
13384 wxImage *arg1 = (wxImage *) 0 ;
13385 wxString *arg2 = 0 ;
13386 int result;
13387 bool temp2 = false ;
13388 PyObject * obj0 = 0 ;
13389 PyObject * obj1 = 0 ;
13390 char *kwnames[] = {
13391 (char *) "self",(char *) "name", NULL
13392 };
13393
13394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13396 if (SWIG_arg_fail(1)) SWIG_fail;
13397 {
13398 arg2 = wxString_in_helper(obj1);
13399 if (arg2 == NULL) SWIG_fail;
13400 temp2 = true;
13401 }
13402 {
13403 PyThreadState* __tstate = wxPyBeginAllowThreads();
13404 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13405
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 {
13410 resultobj = SWIG_From_int((int)(result));
13411 }
13412 {
13413 if (temp2)
13414 delete arg2;
13415 }
13416 return resultobj;
13417 fail:
13418 {
13419 if (temp2)
13420 delete arg2;
13421 }
13422 return NULL;
13423 }
13424
13425
13426 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj;
13428 wxImage *arg1 = (wxImage *) 0 ;
13429 wxString *arg2 = 0 ;
13430 bool result;
13431 bool temp2 = false ;
13432 PyObject * obj0 = 0 ;
13433 PyObject * obj1 = 0 ;
13434 char *kwnames[] = {
13435 (char *) "self",(char *) "name", NULL
13436 };
13437
13438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13440 if (SWIG_arg_fail(1)) SWIG_fail;
13441 {
13442 arg2 = wxString_in_helper(obj1);
13443 if (arg2 == NULL) SWIG_fail;
13444 temp2 = true;
13445 }
13446 {
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13449
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13455 }
13456 {
13457 if (temp2)
13458 delete arg2;
13459 }
13460 return resultobj;
13461 fail:
13462 {
13463 if (temp2)
13464 delete arg2;
13465 }
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj;
13472 wxImage *arg1 = (wxImage *) 0 ;
13473 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13474 unsigned long result;
13475 PyObject * obj0 = 0 ;
13476 PyObject * obj1 = 0 ;
13477 char *kwnames[] = {
13478 (char *) "self",(char *) "stopafter", NULL
13479 };
13480
13481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13483 if (SWIG_arg_fail(1)) SWIG_fail;
13484 if (obj1) {
13485 {
13486 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13487 if (SWIG_arg_fail(2)) SWIG_fail;
13488 }
13489 }
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (unsigned long)(arg1)->CountColours(arg2);
13493
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13499 }
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 wxImageHistogram *arg2 = 0 ;
13510 unsigned long result;
13511 PyObject * obj0 = 0 ;
13512 PyObject * obj1 = 0 ;
13513 char *kwnames[] = {
13514 (char *) "self",(char *) "h", NULL
13515 };
13516
13517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13519 if (SWIG_arg_fail(1)) SWIG_fail;
13520 {
13521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13522 if (SWIG_arg_fail(2)) SWIG_fail;
13523 if (arg2 == NULL) {
13524 SWIG_null_ref("wxImageHistogram");
13525 }
13526 if (SWIG_arg_fail(2)) SWIG_fail;
13527 }
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13531
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 {
13536 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13537 }
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj;
13546 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13547 PyObject * obj0 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "handler", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13554 if (SWIG_arg_fail(1)) SWIG_fail;
13555 {
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 wxImage::AddHandler(arg1);
13558
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 Py_INCREF(Py_None); resultobj = Py_None;
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj;
13571 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13572 PyObject * obj0 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "handler", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(1)) SWIG_fail;
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 wxImage::InsertHandler(arg1);
13583
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 Py_INCREF(Py_None); resultobj = Py_None;
13588 return resultobj;
13589 fail:
13590 return NULL;
13591 }
13592
13593
13594 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13595 PyObject *resultobj;
13596 wxString *arg1 = 0 ;
13597 bool result;
13598 bool temp1 = false ;
13599 PyObject * obj0 = 0 ;
13600 char *kwnames[] = {
13601 (char *) "name", NULL
13602 };
13603
13604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13605 {
13606 arg1 = wxString_in_helper(obj0);
13607 if (arg1 == NULL) SWIG_fail;
13608 temp1 = true;
13609 }
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13613
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 {
13618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13619 }
13620 {
13621 if (temp1)
13622 delete arg1;
13623 }
13624 return resultobj;
13625 fail:
13626 {
13627 if (temp1)
13628 delete arg1;
13629 }
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxString result;
13637 char *kwnames[] = {
13638 NULL
13639 };
13640
13641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = wxImage::GetImageExtWildcard();
13645
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 #if wxUSE_UNICODE
13651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13652 #else
13653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13654 #endif
13655 }
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj;
13664 wxImage *arg1 = (wxImage *) 0 ;
13665 int arg2 = (int) -1 ;
13666 wxBitmap result;
13667 PyObject * obj0 = 0 ;
13668 PyObject * obj1 = 0 ;
13669 char *kwnames[] = {
13670 (char *) "self",(char *) "depth", NULL
13671 };
13672
13673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13675 if (SWIG_arg_fail(1)) SWIG_fail;
13676 if (obj1) {
13677 {
13678 arg2 = (int)(SWIG_As_int(obj1));
13679 if (SWIG_arg_fail(2)) SWIG_fail;
13680 }
13681 }
13682 {
13683 if (!wxPyCheckForApp()) SWIG_fail;
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = wxImage_ConvertToBitmap(arg1,arg2);
13686
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 {
13691 wxBitmap * resultptr;
13692 resultptr = new wxBitmap((wxBitmap &)(result));
13693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13694 }
13695 return resultobj;
13696 fail:
13697 return NULL;
13698 }
13699
13700
13701 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj;
13703 wxImage *arg1 = (wxImage *) 0 ;
13704 unsigned char arg2 ;
13705 unsigned char arg3 ;
13706 unsigned char arg4 ;
13707 wxBitmap result;
13708 PyObject * obj0 = 0 ;
13709 PyObject * obj1 = 0 ;
13710 PyObject * obj2 = 0 ;
13711 PyObject * obj3 = 0 ;
13712 char *kwnames[] = {
13713 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13714 };
13715
13716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13718 if (SWIG_arg_fail(1)) SWIG_fail;
13719 {
13720 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13721 if (SWIG_arg_fail(2)) SWIG_fail;
13722 }
13723 {
13724 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13725 if (SWIG_arg_fail(3)) SWIG_fail;
13726 }
13727 {
13728 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13729 if (SWIG_arg_fail(4)) SWIG_fail;
13730 }
13731 {
13732 if (!wxPyCheckForApp()) SWIG_fail;
13733 PyThreadState* __tstate = wxPyBeginAllowThreads();
13734 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13735
13736 wxPyEndAllowThreads(__tstate);
13737 if (PyErr_Occurred()) SWIG_fail;
13738 }
13739 {
13740 wxBitmap * resultptr;
13741 resultptr = new wxBitmap((wxBitmap &)(result));
13742 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13743 }
13744 return resultobj;
13745 fail:
13746 return NULL;
13747 }
13748
13749
13750 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13751 PyObject *obj;
13752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13753 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13754 Py_INCREF(obj);
13755 return Py_BuildValue((char *)"");
13756 }
13757 static int _wrap_NullImage_set(PyObject *) {
13758 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13759 return 1;
13760 }
13761
13762
13763 static PyObject *_wrap_NullImage_get(void) {
13764 PyObject *pyobj;
13765
13766 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13767 return pyobj;
13768 }
13769
13770
13771 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13772 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13773 return 1;
13774 }
13775
13776
13777 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13778 PyObject *pyobj;
13779
13780 {
13781 #if wxUSE_UNICODE
13782 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13783 #else
13784 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13785 #endif
13786 }
13787 return pyobj;
13788 }
13789
13790
13791 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13792 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13793 return 1;
13794 }
13795
13796
13797 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13798 PyObject *pyobj;
13799
13800 {
13801 #if wxUSE_UNICODE
13802 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13803 #else
13804 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13805 #endif
13806 }
13807 return pyobj;
13808 }
13809
13810
13811 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13812 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13813 return 1;
13814 }
13815
13816
13817 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13818 PyObject *pyobj;
13819
13820 {
13821 #if wxUSE_UNICODE
13822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13823 #else
13824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13825 #endif
13826 }
13827 return pyobj;
13828 }
13829
13830
13831 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13832 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13833 return 1;
13834 }
13835
13836
13837 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13838 PyObject *pyobj;
13839
13840 {
13841 #if wxUSE_UNICODE
13842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13843 #else
13844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13845 #endif
13846 }
13847 return pyobj;
13848 }
13849
13850
13851 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13852 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13853 return 1;
13854 }
13855
13856
13857 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13858 PyObject *pyobj;
13859
13860 {
13861 #if wxUSE_UNICODE
13862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13863 #else
13864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13865 #endif
13866 }
13867 return pyobj;
13868 }
13869
13870
13871 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13872 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13873 return 1;
13874 }
13875
13876
13877 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13878 PyObject *pyobj;
13879
13880 {
13881 #if wxUSE_UNICODE
13882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13883 #else
13884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13885 #endif
13886 }
13887 return pyobj;
13888 }
13889
13890
13891 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13892 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13893 return 1;
13894 }
13895
13896
13897 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13898 PyObject *pyobj;
13899
13900 {
13901 #if wxUSE_UNICODE
13902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13903 #else
13904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13905 #endif
13906 }
13907 return pyobj;
13908 }
13909
13910
13911 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13912 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13913 return 1;
13914 }
13915
13916
13917 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13918 PyObject *pyobj;
13919
13920 {
13921 #if wxUSE_UNICODE
13922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13923 #else
13924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13925 #endif
13926 }
13927 return pyobj;
13928 }
13929
13930
13931 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13932 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13933 return 1;
13934 }
13935
13936
13937 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13938 PyObject *pyobj;
13939
13940 {
13941 #if wxUSE_UNICODE
13942 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13943 #else
13944 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13945 #endif
13946 }
13947 return pyobj;
13948 }
13949
13950
13951 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13952 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13953 return 1;
13954 }
13955
13956
13957 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13958 PyObject *pyobj;
13959
13960 {
13961 #if wxUSE_UNICODE
13962 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13963 #else
13964 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13965 #endif
13966 }
13967 return pyobj;
13968 }
13969
13970
13971 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13972 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13973 return 1;
13974 }
13975
13976
13977 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13978 PyObject *pyobj;
13979
13980 {
13981 #if wxUSE_UNICODE
13982 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13983 #else
13984 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13985 #endif
13986 }
13987 return pyobj;
13988 }
13989
13990
13991 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13992 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13993 return 1;
13994 }
13995
13996
13997 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13998 PyObject *pyobj;
13999
14000 {
14001 #if wxUSE_UNICODE
14002 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14003 #else
14004 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14005 #endif
14006 }
14007 return pyobj;
14008 }
14009
14010
14011 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14012 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14013 return 1;
14014 }
14015
14016
14017 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14018 PyObject *pyobj;
14019
14020 {
14021 #if wxUSE_UNICODE
14022 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14023 #else
14024 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14025 #endif
14026 }
14027 return pyobj;
14028 }
14029
14030
14031 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14032 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14033 return 1;
14034 }
14035
14036
14037 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14038 PyObject *pyobj;
14039
14040 {
14041 #if wxUSE_UNICODE
14042 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14043 #else
14044 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14045 #endif
14046 }
14047 return pyobj;
14048 }
14049
14050
14051 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14052 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14053 return 1;
14054 }
14055
14056
14057 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14058 PyObject *pyobj;
14059
14060 {
14061 #if wxUSE_UNICODE
14062 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14063 #else
14064 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14065 #endif
14066 }
14067 return pyobj;
14068 }
14069
14070
14071 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxBMPHandler *result;
14074 char *kwnames[] = {
14075 NULL
14076 };
14077
14078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (wxBMPHandler *)new wxBMPHandler();
14082
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14094 PyObject *obj;
14095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14096 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14097 Py_INCREF(obj);
14098 return Py_BuildValue((char *)"");
14099 }
14100 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14101 PyObject *resultobj;
14102 wxICOHandler *result;
14103 char *kwnames[] = {
14104 NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 result = (wxICOHandler *)new wxICOHandler();
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14116 return resultobj;
14117 fail:
14118 return NULL;
14119 }
14120
14121
14122 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14123 PyObject *obj;
14124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14125 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14126 Py_INCREF(obj);
14127 return Py_BuildValue((char *)"");
14128 }
14129 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxCURHandler *result;
14132 char *kwnames[] = {
14133 NULL
14134 };
14135
14136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (wxCURHandler *)new wxCURHandler();
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14152 PyObject *obj;
14153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14154 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14155 Py_INCREF(obj);
14156 return Py_BuildValue((char *)"");
14157 }
14158 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj;
14160 wxANIHandler *result;
14161 char *kwnames[] = {
14162 NULL
14163 };
14164
14165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 result = (wxANIHandler *)new wxANIHandler();
14169
14170 wxPyEndAllowThreads(__tstate);
14171 if (PyErr_Occurred()) SWIG_fail;
14172 }
14173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14181 PyObject *obj;
14182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14183 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14184 Py_INCREF(obj);
14185 return Py_BuildValue((char *)"");
14186 }
14187 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14188 PyObject *resultobj;
14189 wxPNGHandler *result;
14190 char *kwnames[] = {
14191 NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 result = (wxPNGHandler *)new wxPNGHandler();
14198
14199 wxPyEndAllowThreads(__tstate);
14200 if (PyErr_Occurred()) SWIG_fail;
14201 }
14202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14203 return resultobj;
14204 fail:
14205 return NULL;
14206 }
14207
14208
14209 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14210 PyObject *obj;
14211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14212 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14213 Py_INCREF(obj);
14214 return Py_BuildValue((char *)"");
14215 }
14216 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj;
14218 wxGIFHandler *result;
14219 char *kwnames[] = {
14220 NULL
14221 };
14222
14223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (wxGIFHandler *)new wxGIFHandler();
14227
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14239 PyObject *obj;
14240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14241 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14242 Py_INCREF(obj);
14243 return Py_BuildValue((char *)"");
14244 }
14245 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj;
14247 wxPCXHandler *result;
14248 char *kwnames[] = {
14249 NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (wxPCXHandler *)new wxPCXHandler();
14256
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14268 PyObject *obj;
14269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14270 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14271 Py_INCREF(obj);
14272 return Py_BuildValue((char *)"");
14273 }
14274 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14275 PyObject *resultobj;
14276 wxJPEGHandler *result;
14277 char *kwnames[] = {
14278 NULL
14279 };
14280
14281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (wxJPEGHandler *)new wxJPEGHandler();
14285
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14297 PyObject *obj;
14298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14299 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14300 Py_INCREF(obj);
14301 return Py_BuildValue((char *)"");
14302 }
14303 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj;
14305 wxPNMHandler *result;
14306 char *kwnames[] = {
14307 NULL
14308 };
14309
14310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (wxPNMHandler *)new wxPNMHandler();
14314
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14326 PyObject *obj;
14327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14328 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14329 Py_INCREF(obj);
14330 return Py_BuildValue((char *)"");
14331 }
14332 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxXPMHandler *result;
14335 char *kwnames[] = {
14336 NULL
14337 };
14338
14339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (wxXPMHandler *)new wxXPMHandler();
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14355 PyObject *obj;
14356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14357 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14358 Py_INCREF(obj);
14359 return Py_BuildValue((char *)"");
14360 }
14361 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14362 PyObject *resultobj;
14363 wxTIFFHandler *result;
14364 char *kwnames[] = {
14365 NULL
14366 };
14367
14368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (wxTIFFHandler *)new wxTIFFHandler();
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14384 PyObject *obj;
14385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14386 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14387 Py_INCREF(obj);
14388 return Py_BuildValue((char *)"");
14389 }
14390 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj;
14392 wxImage *arg1 = 0 ;
14393 wxImage *arg2 = 0 ;
14394 int arg3 = (int) 236 ;
14395 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14396 bool result;
14397 PyObject * obj0 = 0 ;
14398 PyObject * obj1 = 0 ;
14399 PyObject * obj2 = 0 ;
14400 PyObject * obj3 = 0 ;
14401 char *kwnames[] = {
14402 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14403 };
14404
14405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14406 {
14407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14408 if (SWIG_arg_fail(1)) SWIG_fail;
14409 if (arg1 == NULL) {
14410 SWIG_null_ref("wxImage");
14411 }
14412 if (SWIG_arg_fail(1)) SWIG_fail;
14413 }
14414 {
14415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(2)) SWIG_fail;
14417 if (arg2 == NULL) {
14418 SWIG_null_ref("wxImage");
14419 }
14420 if (SWIG_arg_fail(2)) SWIG_fail;
14421 }
14422 if (obj2) {
14423 {
14424 arg3 = (int)(SWIG_As_int(obj2));
14425 if (SWIG_arg_fail(3)) SWIG_fail;
14426 }
14427 }
14428 if (obj3) {
14429 {
14430 arg4 = (int)(SWIG_As_int(obj3));
14431 if (SWIG_arg_fail(4)) SWIG_fail;
14432 }
14433 }
14434 {
14435 PyThreadState* __tstate = wxPyBeginAllowThreads();
14436 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14437
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 {
14442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14443 }
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14451 PyObject *obj;
14452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14453 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14454 Py_INCREF(obj);
14455 return Py_BuildValue((char *)"");
14456 }
14457 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxEvtHandler *result;
14460 char *kwnames[] = {
14461 NULL
14462 };
14463
14464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 result = (wxEvtHandler *)new wxEvtHandler();
14468
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14482 wxEvtHandler *result;
14483 PyObject * obj0 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 {
14499 resultobj = wxPyMake_wxObject(result, 0);
14500 }
14501 return resultobj;
14502 fail:
14503 return NULL;
14504 }
14505
14506
14507 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj;
14509 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14510 wxEvtHandler *result;
14511 PyObject * obj0 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14522
14523 wxPyEndAllowThreads(__tstate);
14524 if (PyErr_Occurred()) SWIG_fail;
14525 }
14526 {
14527 resultobj = wxPyMake_wxObject(result, 0);
14528 }
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14538 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 char *kwnames[] = {
14542 (char *) "self",(char *) "handler", NULL
14543 };
14544
14545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14547 if (SWIG_arg_fail(1)) SWIG_fail;
14548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14549 if (SWIG_arg_fail(2)) SWIG_fail;
14550 {
14551 PyThreadState* __tstate = wxPyBeginAllowThreads();
14552 (arg1)->SetNextHandler(arg2);
14553
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 Py_INCREF(Py_None); resultobj = Py_None;
14558 return resultobj;
14559 fail:
14560 return NULL;
14561 }
14562
14563
14564 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14565 PyObject *resultobj;
14566 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14567 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14568 PyObject * obj0 = 0 ;
14569 PyObject * obj1 = 0 ;
14570 char *kwnames[] = {
14571 (char *) "self",(char *) "handler", NULL
14572 };
14573
14574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14578 if (SWIG_arg_fail(2)) SWIG_fail;
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 (arg1)->SetPreviousHandler(arg2);
14582
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 Py_INCREF(Py_None); resultobj = Py_None;
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14594 PyObject *resultobj;
14595 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14596 bool result;
14597 PyObject * obj0 = 0 ;
14598 char *kwnames[] = {
14599 (char *) "self", NULL
14600 };
14601
14602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14604 if (SWIG_arg_fail(1)) SWIG_fail;
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (bool)(arg1)->GetEvtHandlerEnabled();
14608
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14614 }
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14622 PyObject *resultobj;
14623 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14624 bool arg2 ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "self",(char *) "enabled", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(1)) SWIG_fail;
14634 {
14635 arg2 = (bool)(SWIG_As_bool(obj1));
14636 if (SWIG_arg_fail(2)) SWIG_fail;
14637 }
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 (arg1)->SetEvtHandlerEnabled(arg2);
14641
14642 wxPyEndAllowThreads(__tstate);
14643 if (PyErr_Occurred()) SWIG_fail;
14644 }
14645 Py_INCREF(Py_None); resultobj = Py_None;
14646 return resultobj;
14647 fail:
14648 return NULL;
14649 }
14650
14651
14652 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj;
14654 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14655 wxEvent *arg2 = 0 ;
14656 bool result;
14657 PyObject * obj0 = 0 ;
14658 PyObject * obj1 = 0 ;
14659 char *kwnames[] = {
14660 (char *) "self",(char *) "event", NULL
14661 };
14662
14663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14665 if (SWIG_arg_fail(1)) SWIG_fail;
14666 {
14667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14668 if (SWIG_arg_fail(2)) SWIG_fail;
14669 if (arg2 == NULL) {
14670 SWIG_null_ref("wxEvent");
14671 }
14672 if (SWIG_arg_fail(2)) SWIG_fail;
14673 }
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (bool)(arg1)->ProcessEvent(*arg2);
14677
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 {
14682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14683 }
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj;
14692 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14693 wxEvent *arg2 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 char *kwnames[] = {
14697 (char *) "self",(char *) "event", NULL
14698 };
14699
14700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14702 if (SWIG_arg_fail(1)) SWIG_fail;
14703 {
14704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14705 if (SWIG_arg_fail(2)) SWIG_fail;
14706 if (arg2 == NULL) {
14707 SWIG_null_ref("wxEvent");
14708 }
14709 if (SWIG_arg_fail(2)) SWIG_fail;
14710 }
14711 {
14712 PyThreadState* __tstate = wxPyBeginAllowThreads();
14713 (arg1)->AddPendingEvent(*arg2);
14714
14715 wxPyEndAllowThreads(__tstate);
14716 if (PyErr_Occurred()) SWIG_fail;
14717 }
14718 Py_INCREF(Py_None); resultobj = Py_None;
14719 return resultobj;
14720 fail:
14721 return NULL;
14722 }
14723
14724
14725 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14726 PyObject *resultobj;
14727 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14728 PyObject * obj0 = 0 ;
14729 char *kwnames[] = {
14730 (char *) "self", NULL
14731 };
14732
14733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14735 if (SWIG_arg_fail(1)) SWIG_fail;
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 (arg1)->ProcessPendingEvents();
14739
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 Py_INCREF(Py_None); resultobj = Py_None;
14744 return resultobj;
14745 fail:
14746 return NULL;
14747 }
14748
14749
14750 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj;
14752 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14753 int arg2 ;
14754 int arg3 ;
14755 int arg4 ;
14756 PyObject *arg5 = (PyObject *) 0 ;
14757 PyObject * obj0 = 0 ;
14758 PyObject * obj1 = 0 ;
14759 PyObject * obj2 = 0 ;
14760 PyObject * obj3 = 0 ;
14761 PyObject * obj4 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14768 if (SWIG_arg_fail(1)) SWIG_fail;
14769 {
14770 arg2 = (int)(SWIG_As_int(obj1));
14771 if (SWIG_arg_fail(2)) SWIG_fail;
14772 }
14773 {
14774 arg3 = (int)(SWIG_As_int(obj2));
14775 if (SWIG_arg_fail(3)) SWIG_fail;
14776 }
14777 {
14778 arg4 = (int)(SWIG_As_int(obj3));
14779 if (SWIG_arg_fail(4)) SWIG_fail;
14780 }
14781 arg5 = obj4;
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 Py_INCREF(Py_None); resultobj = Py_None;
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14799 int arg2 ;
14800 int arg3 = (int) -1 ;
14801 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14802 bool result;
14803 PyObject * obj0 = 0 ;
14804 PyObject * obj1 = 0 ;
14805 PyObject * obj2 = 0 ;
14806 PyObject * obj3 = 0 ;
14807 char *kwnames[] = {
14808 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14809 };
14810
14811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14813 if (SWIG_arg_fail(1)) SWIG_fail;
14814 {
14815 arg2 = (int)(SWIG_As_int(obj1));
14816 if (SWIG_arg_fail(2)) SWIG_fail;
14817 }
14818 if (obj2) {
14819 {
14820 arg3 = (int)(SWIG_As_int(obj2));
14821 if (SWIG_arg_fail(3)) SWIG_fail;
14822 }
14823 }
14824 if (obj3) {
14825 {
14826 arg4 = (wxEventType)(SWIG_As_int(obj3));
14827 if (SWIG_arg_fail(4)) SWIG_fail;
14828 }
14829 }
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14833
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 {
14838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14839 }
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj;
14848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14849 PyObject *arg2 = (PyObject *) 0 ;
14850 bool arg3 = (bool) true ;
14851 PyObject * obj0 = 0 ;
14852 PyObject * obj1 = 0 ;
14853 PyObject * obj2 = 0 ;
14854 char *kwnames[] = {
14855 (char *) "self",(char *) "_self",(char *) "incref", NULL
14856 };
14857
14858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14860 if (SWIG_arg_fail(1)) SWIG_fail;
14861 arg2 = obj1;
14862 if (obj2) {
14863 {
14864 arg3 = (bool)(SWIG_As_bool(obj2));
14865 if (SWIG_arg_fail(3)) SWIG_fail;
14866 }
14867 }
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14871
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 Py_INCREF(Py_None); resultobj = Py_None;
14876 return resultobj;
14877 fail:
14878 return NULL;
14879 }
14880
14881
14882 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14883 PyObject *obj;
14884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14885 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14886 Py_INCREF(obj);
14887 return Py_BuildValue((char *)"");
14888 }
14889 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj;
14891 wxEventType result;
14892 char *kwnames[] = {
14893 NULL
14894 };
14895
14896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (wxEventType)wxNewEventType();
14900
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = SWIG_From_int((int)(result));
14906 }
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj;
14915 wxEvent *arg1 = (wxEvent *) 0 ;
14916 PyObject * obj0 = 0 ;
14917 char *kwnames[] = {
14918 (char *) "self", NULL
14919 };
14920
14921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14923 if (SWIG_arg_fail(1)) SWIG_fail;
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 delete arg1;
14927
14928 wxPyEndAllowThreads(__tstate);
14929 if (PyErr_Occurred()) SWIG_fail;
14930 }
14931 Py_INCREF(Py_None); resultobj = Py_None;
14932 return resultobj;
14933 fail:
14934 return NULL;
14935 }
14936
14937
14938 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14939 PyObject *resultobj;
14940 wxEvent *arg1 = (wxEvent *) 0 ;
14941 wxEventType arg2 ;
14942 PyObject * obj0 = 0 ;
14943 PyObject * obj1 = 0 ;
14944 char *kwnames[] = {
14945 (char *) "self",(char *) "typ", NULL
14946 };
14947
14948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14950 if (SWIG_arg_fail(1)) SWIG_fail;
14951 {
14952 arg2 = (wxEventType)(SWIG_As_int(obj1));
14953 if (SWIG_arg_fail(2)) SWIG_fail;
14954 }
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 (arg1)->SetEventType(arg2);
14958
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 Py_INCREF(Py_None); resultobj = Py_None;
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxEvent *arg1 = (wxEvent *) 0 ;
14972 wxEventType result;
14973 PyObject * obj0 = 0 ;
14974 char *kwnames[] = {
14975 (char *) "self", NULL
14976 };
14977
14978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14980 if (SWIG_arg_fail(1)) SWIG_fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = SWIG_From_int((int)(result));
14990 }
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxEvent *arg1 = (wxEvent *) 0 ;
15000 wxObject *result;
15001 PyObject * obj0 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15012
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 {
15017 resultobj = wxPyMake_wxObject(result, 0);
15018 }
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj;
15027 wxEvent *arg1 = (wxEvent *) 0 ;
15028 wxObject *arg2 = (wxObject *) 0 ;
15029 PyObject * obj0 = 0 ;
15030 PyObject * obj1 = 0 ;
15031 char *kwnames[] = {
15032 (char *) "self",(char *) "obj", NULL
15033 };
15034
15035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15037 if (SWIG_arg_fail(1)) SWIG_fail;
15038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15039 if (SWIG_arg_fail(2)) SWIG_fail;
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 (arg1)->SetEventObject(arg2);
15043
15044 wxPyEndAllowThreads(__tstate);
15045 if (PyErr_Occurred()) SWIG_fail;
15046 }
15047 Py_INCREF(Py_None); resultobj = Py_None;
15048 return resultobj;
15049 fail:
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxEvent *arg1 = (wxEvent *) 0 ;
15057 long result;
15058 PyObject * obj0 = 0 ;
15059 char *kwnames[] = {
15060 (char *) "self", NULL
15061 };
15062
15063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15065 if (SWIG_arg_fail(1)) SWIG_fail;
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15069
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 {
15074 resultobj = SWIG_From_long((long)(result));
15075 }
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15083 PyObject *resultobj;
15084 wxEvent *arg1 = (wxEvent *) 0 ;
15085 long arg2 = (long) 0 ;
15086 PyObject * obj0 = 0 ;
15087 PyObject * obj1 = 0 ;
15088 char *kwnames[] = {
15089 (char *) "self",(char *) "ts", NULL
15090 };
15091
15092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15094 if (SWIG_arg_fail(1)) SWIG_fail;
15095 if (obj1) {
15096 {
15097 arg2 = (long)(SWIG_As_long(obj1));
15098 if (SWIG_arg_fail(2)) SWIG_fail;
15099 }
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 (arg1)->SetTimestamp(arg2);
15104
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 Py_INCREF(Py_None); resultobj = Py_None;
15109 return resultobj;
15110 fail:
15111 return NULL;
15112 }
15113
15114
15115 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15116 PyObject *resultobj;
15117 wxEvent *arg1 = (wxEvent *) 0 ;
15118 int result;
15119 PyObject * obj0 = 0 ;
15120 char *kwnames[] = {
15121 (char *) "self", NULL
15122 };
15123
15124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15126 if (SWIG_arg_fail(1)) SWIG_fail;
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 result = (int)((wxEvent const *)arg1)->GetId();
15130
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 {
15135 resultobj = SWIG_From_int((int)(result));
15136 }
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15144 PyObject *resultobj;
15145 wxEvent *arg1 = (wxEvent *) 0 ;
15146 int arg2 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self",(char *) "Id", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 {
15157 arg2 = (int)(SWIG_As_int(obj1));
15158 if (SWIG_arg_fail(2)) SWIG_fail;
15159 }
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 (arg1)->SetId(arg2);
15163
15164 wxPyEndAllowThreads(__tstate);
15165 if (PyErr_Occurred()) SWIG_fail;
15166 }
15167 Py_INCREF(Py_None); resultobj = Py_None;
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj;
15176 wxEvent *arg1 = (wxEvent *) 0 ;
15177 bool result;
15178 PyObject * obj0 = 0 ;
15179 char *kwnames[] = {
15180 (char *) "self", NULL
15181 };
15182
15183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15185 if (SWIG_arg_fail(1)) SWIG_fail;
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 {
15194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15195 }
15196 return resultobj;
15197 fail:
15198 return NULL;
15199 }
15200
15201
15202 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15203 PyObject *resultobj;
15204 wxEvent *arg1 = (wxEvent *) 0 ;
15205 bool arg2 = (bool) true ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self",(char *) "skip", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 if (obj1) {
15216 {
15217 arg2 = (bool)(SWIG_As_bool(obj1));
15218 if (SWIG_arg_fail(2)) SWIG_fail;
15219 }
15220 }
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 (arg1)->Skip(arg2);
15224
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 Py_INCREF(Py_None); resultobj = Py_None;
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj;
15237 wxEvent *arg1 = (wxEvent *) 0 ;
15238 bool result;
15239 PyObject * obj0 = 0 ;
15240 char *kwnames[] = {
15241 (char *) "self", NULL
15242 };
15243
15244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(1)) SWIG_fail;
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15250
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 {
15255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15256 }
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj;
15265 wxEvent *arg1 = (wxEvent *) 0 ;
15266 bool result;
15267 PyObject * obj0 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self", NULL
15270 };
15271
15272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15274 if (SWIG_arg_fail(1)) SWIG_fail;
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15278
15279 wxPyEndAllowThreads(__tstate);
15280 if (PyErr_Occurred()) SWIG_fail;
15281 }
15282 {
15283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15284 }
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj;
15293 wxEvent *arg1 = (wxEvent *) 0 ;
15294 int result;
15295 PyObject * obj0 = 0 ;
15296 char *kwnames[] = {
15297 (char *) "self", NULL
15298 };
15299
15300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15302 if (SWIG_arg_fail(1)) SWIG_fail;
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (int)(arg1)->StopPropagation();
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 {
15311 resultobj = SWIG_From_int((int)(result));
15312 }
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxEvent *arg1 = (wxEvent *) 0 ;
15322 int arg2 ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 char *kwnames[] = {
15326 (char *) "self",(char *) "propagationLevel", NULL
15327 };
15328
15329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15331 if (SWIG_arg_fail(1)) SWIG_fail;
15332 {
15333 arg2 = (int)(SWIG_As_int(obj1));
15334 if (SWIG_arg_fail(2)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 (arg1)->ResumePropagation(arg2);
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 Py_INCREF(Py_None); resultobj = Py_None;
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj;
15352 wxEvent *arg1 = (wxEvent *) 0 ;
15353 wxEvent *result;
15354 PyObject * obj0 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (wxEvent *)(arg1)->Clone();
15365
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15377 PyObject *obj;
15378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15379 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15380 Py_INCREF(obj);
15381 return Py_BuildValue((char *)"");
15382 }
15383 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj;
15385 wxEvent *arg1 = 0 ;
15386 wxPropagationDisabler *result;
15387 PyObject * obj0 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "event", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15393 {
15394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15395 if (SWIG_arg_fail(1)) SWIG_fail;
15396 if (arg1 == NULL) {
15397 SWIG_null_ref("wxEvent");
15398 }
15399 if (SWIG_arg_fail(1)) SWIG_fail;
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15404
15405 wxPyEndAllowThreads(__tstate);
15406 if (PyErr_Occurred()) SWIG_fail;
15407 }
15408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15409 return resultobj;
15410 fail:
15411 return NULL;
15412 }
15413
15414
15415 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15416 PyObject *resultobj;
15417 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15418 PyObject * obj0 = 0 ;
15419 char *kwnames[] = {
15420 (char *) "self", NULL
15421 };
15422
15423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15425 if (SWIG_arg_fail(1)) SWIG_fail;
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 delete arg1;
15429
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 Py_INCREF(Py_None); resultobj = Py_None;
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15441 PyObject *obj;
15442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15443 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15444 Py_INCREF(obj);
15445 return Py_BuildValue((char *)"");
15446 }
15447 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj;
15449 wxEvent *arg1 = 0 ;
15450 wxPropagateOnce *result;
15451 PyObject * obj0 = 0 ;
15452 char *kwnames[] = {
15453 (char *) "event", NULL
15454 };
15455
15456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15457 {
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 if (arg1 == NULL) {
15461 SWIG_null_ref("wxEvent");
15462 }
15463 if (SWIG_arg_fail(1)) SWIG_fail;
15464 }
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15468
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15473 return resultobj;
15474 fail:
15475 return NULL;
15476 }
15477
15478
15479 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15480 PyObject *resultobj;
15481 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15482 PyObject * obj0 = 0 ;
15483 char *kwnames[] = {
15484 (char *) "self", NULL
15485 };
15486
15487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15489 if (SWIG_arg_fail(1)) SWIG_fail;
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 delete arg1;
15493
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 Py_INCREF(Py_None); resultobj = Py_None;
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15505 PyObject *obj;
15506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15507 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15508 Py_INCREF(obj);
15509 return Py_BuildValue((char *)"");
15510 }
15511 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15512 PyObject *resultobj;
15513 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15514 int arg2 = (int) 0 ;
15515 wxCommandEvent *result;
15516 PyObject * obj0 = 0 ;
15517 PyObject * obj1 = 0 ;
15518 char *kwnames[] = {
15519 (char *) "commandType",(char *) "winid", NULL
15520 };
15521
15522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15523 if (obj0) {
15524 {
15525 arg1 = (wxEventType)(SWIG_As_int(obj0));
15526 if (SWIG_arg_fail(1)) SWIG_fail;
15527 }
15528 }
15529 if (obj1) {
15530 {
15531 arg2 = (int)(SWIG_As_int(obj1));
15532 if (SWIG_arg_fail(2)) SWIG_fail;
15533 }
15534 }
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15538
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15543 return resultobj;
15544 fail:
15545 return NULL;
15546 }
15547
15548
15549 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15550 PyObject *resultobj;
15551 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15552 int result;
15553 PyObject * obj0 = 0 ;
15554 char *kwnames[] = {
15555 (char *) "self", NULL
15556 };
15557
15558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15560 if (SWIG_arg_fail(1)) SWIG_fail;
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 {
15569 resultobj = SWIG_From_int((int)(result));
15570 }
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj;
15579 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15580 wxString *arg2 = 0 ;
15581 bool temp2 = false ;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 char *kwnames[] = {
15585 (char *) "self",(char *) "s", NULL
15586 };
15587
15588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15590 if (SWIG_arg_fail(1)) SWIG_fail;
15591 {
15592 arg2 = wxString_in_helper(obj1);
15593 if (arg2 == NULL) SWIG_fail;
15594 temp2 = true;
15595 }
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 (arg1)->SetString((wxString const &)*arg2);
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 Py_INCREF(Py_None); resultobj = Py_None;
15604 {
15605 if (temp2)
15606 delete arg2;
15607 }
15608 return resultobj;
15609 fail:
15610 {
15611 if (temp2)
15612 delete arg2;
15613 }
15614 return NULL;
15615 }
15616
15617
15618 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15619 PyObject *resultobj;
15620 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15621 wxString result;
15622 PyObject * obj0 = 0 ;
15623 char *kwnames[] = {
15624 (char *) "self", NULL
15625 };
15626
15627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15629 if (SWIG_arg_fail(1)) SWIG_fail;
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 result = ((wxCommandEvent const *)arg1)->GetString();
15633
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 {
15638 #if wxUSE_UNICODE
15639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15640 #else
15641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15642 #endif
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj;
15652 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15653 bool result;
15654 PyObject * obj0 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj;
15680 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15681 bool result;
15682 PyObject * obj0 = 0 ;
15683 char *kwnames[] = {
15684 (char *) "self", NULL
15685 };
15686
15687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15689 if (SWIG_arg_fail(1)) SWIG_fail;
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15693
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 {
15698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15699 }
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15707 PyObject *resultobj;
15708 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15709 long arg2 ;
15710 PyObject * obj0 = 0 ;
15711 PyObject * obj1 = 0 ;
15712 char *kwnames[] = {
15713 (char *) "self",(char *) "extraLong", NULL
15714 };
15715
15716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15718 if (SWIG_arg_fail(1)) SWIG_fail;
15719 {
15720 arg2 = (long)(SWIG_As_long(obj1));
15721 if (SWIG_arg_fail(2)) SWIG_fail;
15722 }
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 (arg1)->SetExtraLong(arg2);
15726
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 Py_INCREF(Py_None); resultobj = Py_None;
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj;
15739 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15740 long result;
15741 PyObject * obj0 = 0 ;
15742 char *kwnames[] = {
15743 (char *) "self", NULL
15744 };
15745
15746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15748 if (SWIG_arg_fail(1)) SWIG_fail;
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15752
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 {
15757 resultobj = SWIG_From_long((long)(result));
15758 }
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15766 PyObject *resultobj;
15767 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15768 int arg2 ;
15769 PyObject * obj0 = 0 ;
15770 PyObject * obj1 = 0 ;
15771 char *kwnames[] = {
15772 (char *) "self",(char *) "i", NULL
15773 };
15774
15775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15777 if (SWIG_arg_fail(1)) SWIG_fail;
15778 {
15779 arg2 = (int)(SWIG_As_int(obj1));
15780 if (SWIG_arg_fail(2)) SWIG_fail;
15781 }
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 (arg1)->SetInt(arg2);
15785
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 Py_INCREF(Py_None); resultobj = Py_None;
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15797 PyObject *resultobj;
15798 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15799 long result;
15800 PyObject * obj0 = 0 ;
15801 char *kwnames[] = {
15802 (char *) "self", NULL
15803 };
15804
15805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15807 if (SWIG_arg_fail(1)) SWIG_fail;
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15811
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 {
15816 resultobj = SWIG_From_long((long)(result));
15817 }
15818 return resultobj;
15819 fail:
15820 return NULL;
15821 }
15822
15823
15824 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15825 PyObject *resultobj;
15826 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15827 wxEvent *result;
15828 PyObject * obj0 = 0 ;
15829 char *kwnames[] = {
15830 (char *) "self", NULL
15831 };
15832
15833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15835 if (SWIG_arg_fail(1)) SWIG_fail;
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15839
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15851 PyObject *obj;
15852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15853 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15854 Py_INCREF(obj);
15855 return Py_BuildValue((char *)"");
15856 }
15857 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15858 PyObject *resultobj;
15859 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15860 int arg2 = (int) 0 ;
15861 wxNotifyEvent *result;
15862 PyObject * obj0 = 0 ;
15863 PyObject * obj1 = 0 ;
15864 char *kwnames[] = {
15865 (char *) "commandType",(char *) "winid", NULL
15866 };
15867
15868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15869 if (obj0) {
15870 {
15871 arg1 = (wxEventType)(SWIG_As_int(obj0));
15872 if (SWIG_arg_fail(1)) SWIG_fail;
15873 }
15874 }
15875 if (obj1) {
15876 {
15877 arg2 = (int)(SWIG_As_int(obj1));
15878 if (SWIG_arg_fail(2)) SWIG_fail;
15879 }
15880 }
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15884
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj;
15897 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15898 PyObject * obj0 = 0 ;
15899 char *kwnames[] = {
15900 (char *) "self", NULL
15901 };
15902
15903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15905 if (SWIG_arg_fail(1)) SWIG_fail;
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 (arg1)->Veto();
15909
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 Py_INCREF(Py_None); resultobj = Py_None;
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj;
15922 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15923 PyObject * obj0 = 0 ;
15924 char *kwnames[] = {
15925 (char *) "self", NULL
15926 };
15927
15928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15930 if (SWIG_arg_fail(1)) SWIG_fail;
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 (arg1)->Allow();
15934
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 Py_INCREF(Py_None); resultobj = Py_None;
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15948 bool result;
15949 PyObject * obj0 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "self", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (bool)(arg1)->IsAllowed();
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 {
15965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15966 }
15967 return resultobj;
15968 fail:
15969 return NULL;
15970 }
15971
15972
15973 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15974 PyObject *obj;
15975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15976 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15977 Py_INCREF(obj);
15978 return Py_BuildValue((char *)"");
15979 }
15980 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj;
15982 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15983 int arg2 = (int) 0 ;
15984 int arg3 = (int) 0 ;
15985 int arg4 = (int) 0 ;
15986 wxScrollEvent *result;
15987 PyObject * obj0 = 0 ;
15988 PyObject * obj1 = 0 ;
15989 PyObject * obj2 = 0 ;
15990 PyObject * obj3 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15993 };
15994
15995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15996 if (obj0) {
15997 {
15998 arg1 = (wxEventType)(SWIG_As_int(obj0));
15999 if (SWIG_arg_fail(1)) SWIG_fail;
16000 }
16001 }
16002 if (obj1) {
16003 {
16004 arg2 = (int)(SWIG_As_int(obj1));
16005 if (SWIG_arg_fail(2)) SWIG_fail;
16006 }
16007 }
16008 if (obj2) {
16009 {
16010 arg3 = (int)(SWIG_As_int(obj2));
16011 if (SWIG_arg_fail(3)) SWIG_fail;
16012 }
16013 }
16014 if (obj3) {
16015 {
16016 arg4 = (int)(SWIG_As_int(obj3));
16017 if (SWIG_arg_fail(4)) SWIG_fail;
16018 }
16019 }
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16023
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj;
16036 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16037 int result;
16038 PyObject * obj0 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16049
16050 wxPyEndAllowThreads(__tstate);
16051 if (PyErr_Occurred()) SWIG_fail;
16052 }
16053 {
16054 resultobj = SWIG_From_int((int)(result));
16055 }
16056 return resultobj;
16057 fail:
16058 return NULL;
16059 }
16060
16061
16062 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16063 PyObject *resultobj;
16064 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16065 int result;
16066 PyObject * obj0 = 0 ;
16067 char *kwnames[] = {
16068 (char *) "self", NULL
16069 };
16070
16071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16073 if (SWIG_arg_fail(1)) SWIG_fail;
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16077
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 {
16082 resultobj = SWIG_From_int((int)(result));
16083 }
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj;
16092 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16093 int arg2 ;
16094 PyObject * obj0 = 0 ;
16095 PyObject * obj1 = 0 ;
16096 char *kwnames[] = {
16097 (char *) "self",(char *) "orient", NULL
16098 };
16099
16100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16102 if (SWIG_arg_fail(1)) SWIG_fail;
16103 {
16104 arg2 = (int)(SWIG_As_int(obj1));
16105 if (SWIG_arg_fail(2)) SWIG_fail;
16106 }
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 (arg1)->SetOrientation(arg2);
16110
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 Py_INCREF(Py_None); resultobj = Py_None;
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16122 PyObject *resultobj;
16123 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16124 int arg2 ;
16125 PyObject * obj0 = 0 ;
16126 PyObject * obj1 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self",(char *) "pos", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 arg2 = (int)(SWIG_As_int(obj1));
16136 if (SWIG_arg_fail(2)) SWIG_fail;
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->SetPosition(arg2);
16141
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 Py_INCREF(Py_None); resultobj = Py_None;
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16153 PyObject *obj;
16154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16155 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16156 Py_INCREF(obj);
16157 return Py_BuildValue((char *)"");
16158 }
16159 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj;
16161 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16162 int arg2 = (int) 0 ;
16163 int arg3 = (int) 0 ;
16164 wxScrollWinEvent *result;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 PyObject * obj2 = 0 ;
16168 char *kwnames[] = {
16169 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16170 };
16171
16172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16173 if (obj0) {
16174 {
16175 arg1 = (wxEventType)(SWIG_As_int(obj0));
16176 if (SWIG_arg_fail(1)) SWIG_fail;
16177 }
16178 }
16179 if (obj1) {
16180 {
16181 arg2 = (int)(SWIG_As_int(obj1));
16182 if (SWIG_arg_fail(2)) SWIG_fail;
16183 }
16184 }
16185 if (obj2) {
16186 {
16187 arg3 = (int)(SWIG_As_int(obj2));
16188 if (SWIG_arg_fail(3)) SWIG_fail;
16189 }
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj;
16207 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16208 int result;
16209 PyObject * obj0 = 0 ;
16210 char *kwnames[] = {
16211 (char *) "self", NULL
16212 };
16213
16214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16216 if (SWIG_arg_fail(1)) SWIG_fail;
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16220
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 {
16225 resultobj = SWIG_From_int((int)(result));
16226 }
16227 return resultobj;
16228 fail:
16229 return NULL;
16230 }
16231
16232
16233 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16234 PyObject *resultobj;
16235 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16236 int result;
16237 PyObject * obj0 = 0 ;
16238 char *kwnames[] = {
16239 (char *) "self", NULL
16240 };
16241
16242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16244 if (SWIG_arg_fail(1)) SWIG_fail;
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16248
16249 wxPyEndAllowThreads(__tstate);
16250 if (PyErr_Occurred()) SWIG_fail;
16251 }
16252 {
16253 resultobj = SWIG_From_int((int)(result));
16254 }
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16264 int arg2 ;
16265 PyObject * obj0 = 0 ;
16266 PyObject * obj1 = 0 ;
16267 char *kwnames[] = {
16268 (char *) "self",(char *) "orient", NULL
16269 };
16270
16271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16273 if (SWIG_arg_fail(1)) SWIG_fail;
16274 {
16275 arg2 = (int)(SWIG_As_int(obj1));
16276 if (SWIG_arg_fail(2)) SWIG_fail;
16277 }
16278 {
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 (arg1)->SetOrientation(arg2);
16281
16282 wxPyEndAllowThreads(__tstate);
16283 if (PyErr_Occurred()) SWIG_fail;
16284 }
16285 Py_INCREF(Py_None); resultobj = Py_None;
16286 return resultobj;
16287 fail:
16288 return NULL;
16289 }
16290
16291
16292 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj;
16294 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16295 int arg2 ;
16296 PyObject * obj0 = 0 ;
16297 PyObject * obj1 = 0 ;
16298 char *kwnames[] = {
16299 (char *) "self",(char *) "pos", NULL
16300 };
16301
16302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16304 if (SWIG_arg_fail(1)) SWIG_fail;
16305 {
16306 arg2 = (int)(SWIG_As_int(obj1));
16307 if (SWIG_arg_fail(2)) SWIG_fail;
16308 }
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 (arg1)->SetPosition(arg2);
16312
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 Py_INCREF(Py_None); resultobj = Py_None;
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16324 PyObject *obj;
16325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16326 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16327 Py_INCREF(obj);
16328 return Py_BuildValue((char *)"");
16329 }
16330 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16331 PyObject *resultobj;
16332 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16333 wxMouseEvent *result;
16334 PyObject * obj0 = 0 ;
16335 char *kwnames[] = {
16336 (char *) "mouseType", NULL
16337 };
16338
16339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16340 if (obj0) {
16341 {
16342 arg1 = (wxEventType)(SWIG_As_int(obj0));
16343 if (SWIG_arg_fail(1)) SWIG_fail;
16344 }
16345 }
16346 {
16347 PyThreadState* __tstate = wxPyBeginAllowThreads();
16348 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16349
16350 wxPyEndAllowThreads(__tstate);
16351 if (PyErr_Occurred()) SWIG_fail;
16352 }
16353 {
16354 resultobj = wxPyMake_wxObject(result, 1);
16355 }
16356 return resultobj;
16357 fail:
16358 return NULL;
16359 }
16360
16361
16362 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16363 PyObject *resultobj;
16364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16365 bool result;
16366 PyObject * obj0 = 0 ;
16367 char *kwnames[] = {
16368 (char *) "self", NULL
16369 };
16370
16371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16373 if (SWIG_arg_fail(1)) SWIG_fail;
16374 {
16375 PyThreadState* __tstate = wxPyBeginAllowThreads();
16376 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16377
16378 wxPyEndAllowThreads(__tstate);
16379 if (PyErr_Occurred()) SWIG_fail;
16380 }
16381 {
16382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16383 }
16384 return resultobj;
16385 fail:
16386 return NULL;
16387 }
16388
16389
16390 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16391 PyObject *resultobj;
16392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16393 int arg2 = (int) wxMOUSE_BTN_ANY ;
16394 bool result;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 char *kwnames[] = {
16398 (char *) "self",(char *) "but", NULL
16399 };
16400
16401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16403 if (SWIG_arg_fail(1)) SWIG_fail;
16404 if (obj1) {
16405 {
16406 arg2 = (int)(SWIG_As_int(obj1));
16407 if (SWIG_arg_fail(2)) SWIG_fail;
16408 }
16409 }
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16413
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16419 }
16420 return resultobj;
16421 fail:
16422 return NULL;
16423 }
16424
16425
16426 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16427 PyObject *resultobj;
16428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16429 int arg2 = (int) wxMOUSE_BTN_ANY ;
16430 bool result;
16431 PyObject * obj0 = 0 ;
16432 PyObject * obj1 = 0 ;
16433 char *kwnames[] = {
16434 (char *) "self",(char *) "but", NULL
16435 };
16436
16437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16439 if (SWIG_arg_fail(1)) SWIG_fail;
16440 if (obj1) {
16441 {
16442 arg2 = (int)(SWIG_As_int(obj1));
16443 if (SWIG_arg_fail(2)) SWIG_fail;
16444 }
16445 }
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 {
16454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16455 }
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj;
16464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16465 int arg2 = (int) wxMOUSE_BTN_ANY ;
16466 bool result;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char *kwnames[] = {
16470 (char *) "self",(char *) "but", NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 if (obj1) {
16477 {
16478 arg2 = (int)(SWIG_As_int(obj1));
16479 if (SWIG_arg_fail(2)) SWIG_fail;
16480 }
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16485
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 {
16490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16491 }
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj;
16500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16501 int arg2 ;
16502 bool result;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self",(char *) "but", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 {
16513 arg2 = (int)(SWIG_As_int(obj1));
16514 if (SWIG_arg_fail(2)) SWIG_fail;
16515 }
16516 {
16517 PyThreadState* __tstate = wxPyBeginAllowThreads();
16518 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16519
16520 wxPyEndAllowThreads(__tstate);
16521 if (PyErr_Occurred()) SWIG_fail;
16522 }
16523 {
16524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16525 }
16526 return resultobj;
16527 fail:
16528 return NULL;
16529 }
16530
16531
16532 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj;
16534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16535 int arg2 ;
16536 bool result;
16537 PyObject * obj0 = 0 ;
16538 PyObject * obj1 = 0 ;
16539 char *kwnames[] = {
16540 (char *) "self",(char *) "but", NULL
16541 };
16542
16543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16545 if (SWIG_arg_fail(1)) SWIG_fail;
16546 {
16547 arg2 = (int)(SWIG_As_int(obj1));
16548 if (SWIG_arg_fail(2)) SWIG_fail;
16549 }
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16553
16554 wxPyEndAllowThreads(__tstate);
16555 if (PyErr_Occurred()) SWIG_fail;
16556 }
16557 {
16558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16559 }
16560 return resultobj;
16561 fail:
16562 return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16567 PyObject *resultobj;
16568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16569 int result;
16570 PyObject * obj0 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "self", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16581
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 {
16586 resultobj = SWIG_From_int((int)(result));
16587 }
16588 return resultobj;
16589 fail:
16590 return NULL;
16591 }
16592
16593
16594 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16595 PyObject *resultobj;
16596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16597 bool result;
16598 PyObject * obj0 = 0 ;
16599 char *kwnames[] = {
16600 (char *) "self", NULL
16601 };
16602
16603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16605 if (SWIG_arg_fail(1)) SWIG_fail;
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16609
16610 wxPyEndAllowThreads(__tstate);
16611 if (PyErr_Occurred()) SWIG_fail;
16612 }
16613 {
16614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16615 }
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj;
16624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16625 bool result;
16626 PyObject * obj0 = 0 ;
16627 char *kwnames[] = {
16628 (char *) "self", NULL
16629 };
16630
16631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16633 if (SWIG_arg_fail(1)) SWIG_fail;
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16653 bool result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "self", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16665
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 {
16670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16681 bool result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16709 bool result;
16710 PyObject * obj0 = 0 ;
16711 char *kwnames[] = {
16712 (char *) "self", NULL
16713 };
16714
16715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16717 if (SWIG_arg_fail(1)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16737 bool result;
16738 PyObject * obj0 = 0 ;
16739 char *kwnames[] = {
16740 (char *) "self", NULL
16741 };
16742
16743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16745 if (SWIG_arg_fail(1)) SWIG_fail;
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16749
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 {
16754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16755 }
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16765 bool result;
16766 PyObject * obj0 = 0 ;
16767 char *kwnames[] = {
16768 (char *) "self", NULL
16769 };
16770
16771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16773 if (SWIG_arg_fail(1)) SWIG_fail;
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16793 bool result;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj;
16820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16821 bool result;
16822 PyObject * obj0 = 0 ;
16823 char *kwnames[] = {
16824 (char *) "self", NULL
16825 };
16826
16827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16829 if (SWIG_arg_fail(1)) SWIG_fail;
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16833
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 {
16838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16839 }
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16849 bool result;
16850 PyObject * obj0 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16861
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 {
16866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16867 }
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16877 bool result;
16878 PyObject * obj0 = 0 ;
16879 char *kwnames[] = {
16880 (char *) "self", NULL
16881 };
16882
16883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16885 if (SWIG_arg_fail(1)) SWIG_fail;
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16889
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 {
16894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16895 }
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16905 bool result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "self", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16933 bool result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "self", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16951 }
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 bool result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16989 bool result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)(arg1)->LeftIsDown();
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 bool result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)(arg1)->MiddleIsDown();
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17045 bool result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (bool)(arg1)->RightIsDown();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17073 bool result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 {
17090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17091 }
17092 return resultobj;
17093 fail:
17094 return NULL;
17095 }
17096
17097
17098 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17099 PyObject *resultobj;
17100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17101 bool result;
17102 PyObject * obj0 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17113
17114 wxPyEndAllowThreads(__tstate);
17115 if (PyErr_Occurred()) SWIG_fail;
17116 }
17117 {
17118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17119 }
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17129 bool result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 {
17146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17147 }
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17157 bool result;
17158 PyObject * obj0 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17175 }
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17185 wxPoint result;
17186 PyObject * obj0 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (arg1)->GetPosition();
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 wxPoint * resultptr;
17203 resultptr = new wxPoint((wxPoint &)(result));
17204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17205 }
17206 return resultobj;
17207 fail:
17208 return NULL;
17209 }
17210
17211
17212 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17213 PyObject *resultobj;
17214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17215 long *arg2 = (long *) 0 ;
17216 long *arg3 = (long *) 0 ;
17217 long temp2 ;
17218 int res2 = 0 ;
17219 long temp3 ;
17220 int res3 = 0 ;
17221 PyObject * obj0 = 0 ;
17222 char *kwnames[] = {
17223 (char *) "self", NULL
17224 };
17225
17226 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17227 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17230 if (SWIG_arg_fail(1)) SWIG_fail;
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 (arg1)->GetPosition(arg2,arg3);
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 Py_INCREF(Py_None); resultobj = Py_None;
17239 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17240 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17241 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17242 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj;
17251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17252 wxDC *arg2 = 0 ;
17253 wxPoint result;
17254 PyObject * obj0 = 0 ;
17255 PyObject * obj1 = 0 ;
17256 char *kwnames[] = {
17257 (char *) "self",(char *) "dc", NULL
17258 };
17259
17260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17262 if (SWIG_arg_fail(1)) SWIG_fail;
17263 {
17264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(2)) SWIG_fail;
17266 if (arg2 == NULL) {
17267 SWIG_null_ref("wxDC");
17268 }
17269 if (SWIG_arg_fail(2)) SWIG_fail;
17270 }
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 {
17279 wxPoint * resultptr;
17280 resultptr = new wxPoint((wxPoint &)(result));
17281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17282 }
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj;
17291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17292 int result;
17293 PyObject * obj0 = 0 ;
17294 char *kwnames[] = {
17295 (char *) "self", NULL
17296 };
17297
17298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17300 if (SWIG_arg_fail(1)) SWIG_fail;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (int)((wxMouseEvent const *)arg1)->GetX();
17304
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = SWIG_From_int((int)(result));
17310 }
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17318 PyObject *resultobj;
17319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17320 int result;
17321 PyObject * obj0 = 0 ;
17322 char *kwnames[] = {
17323 (char *) "self", NULL
17324 };
17325
17326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17328 if (SWIG_arg_fail(1)) SWIG_fail;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (int)((wxMouseEvent const *)arg1)->GetY();
17332
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 {
17337 resultobj = SWIG_From_int((int)(result));
17338 }
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17348 int result;
17349 PyObject * obj0 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17360
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 resultobj = SWIG_From_int((int)(result));
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 int result;
17377 PyObject * obj0 = 0 ;
17378 char *kwnames[] = {
17379 (char *) "self", NULL
17380 };
17381
17382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17384 if (SWIG_arg_fail(1)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = SWIG_From_int((int)(result));
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 bool result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 int arg2 ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 char *kwnames[] = {
17464 (char *) "self",(char *) "m_x", NULL
17465 };
17466
17467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17469 if (SWIG_arg_fail(1)) SWIG_fail;
17470 {
17471 arg2 = (int)(SWIG_As_int(obj1));
17472 if (SWIG_arg_fail(2)) SWIG_fail;
17473 }
17474 if (arg1) (arg1)->m_x = arg2;
17475
17476 Py_INCREF(Py_None); resultobj = Py_None;
17477 return resultobj;
17478 fail:
17479 return NULL;
17480 }
17481
17482
17483 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17484 PyObject *resultobj;
17485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17486 int result;
17487 PyObject * obj0 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 result = (int) ((arg1)->m_x);
17496
17497 {
17498 resultobj = SWIG_From_int((int)(result));
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17509 int arg2 ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 char *kwnames[] = {
17513 (char *) "self",(char *) "m_y", NULL
17514 };
17515
17516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
17521 if (SWIG_arg_fail(2)) SWIG_fail;
17522 }
17523 if (arg1) (arg1)->m_y = arg2;
17524
17525 Py_INCREF(Py_None); resultobj = Py_None;
17526 return resultobj;
17527 fail:
17528 return NULL;
17529 }
17530
17531
17532 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17533 PyObject *resultobj;
17534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17535 int result;
17536 PyObject * obj0 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 result = (int) ((arg1)->m_y);
17545
17546 {
17547 resultobj = SWIG_From_int((int)(result));
17548 }
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17558 bool arg2 ;
17559 PyObject * obj0 = 0 ;
17560 PyObject * obj1 = 0 ;
17561 char *kwnames[] = {
17562 (char *) "self",(char *) "m_leftDown", NULL
17563 };
17564
17565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17567 if (SWIG_arg_fail(1)) SWIG_fail;
17568 {
17569 arg2 = (bool)(SWIG_As_bool(obj1));
17570 if (SWIG_arg_fail(2)) SWIG_fail;
17571 }
17572 if (arg1) (arg1)->m_leftDown = arg2;
17573
17574 Py_INCREF(Py_None); resultobj = Py_None;
17575 return resultobj;
17576 fail:
17577 return NULL;
17578 }
17579
17580
17581 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17582 PyObject *resultobj;
17583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17584 bool result;
17585 PyObject * obj0 = 0 ;
17586 char *kwnames[] = {
17587 (char *) "self", NULL
17588 };
17589
17590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17592 if (SWIG_arg_fail(1)) SWIG_fail;
17593 result = (bool) ((arg1)->m_leftDown);
17594
17595 {
17596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17597 }
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj;
17606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17607 bool arg2 ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 char *kwnames[] = {
17611 (char *) "self",(char *) "m_middleDown", NULL
17612 };
17613
17614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17616 if (SWIG_arg_fail(1)) SWIG_fail;
17617 {
17618 arg2 = (bool)(SWIG_As_bool(obj1));
17619 if (SWIG_arg_fail(2)) SWIG_fail;
17620 }
17621 if (arg1) (arg1)->m_middleDown = arg2;
17622
17623 Py_INCREF(Py_None); resultobj = Py_None;
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj;
17632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17633 bool result;
17634 PyObject * obj0 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 result = (bool) ((arg1)->m_middleDown);
17643
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool arg2 ;
17657 PyObject * obj0 = 0 ;
17658 PyObject * obj1 = 0 ;
17659 char *kwnames[] = {
17660 (char *) "self",(char *) "m_rightDown", NULL
17661 };
17662
17663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17665 if (SWIG_arg_fail(1)) SWIG_fail;
17666 {
17667 arg2 = (bool)(SWIG_As_bool(obj1));
17668 if (SWIG_arg_fail(2)) SWIG_fail;
17669 }
17670 if (arg1) (arg1)->m_rightDown = arg2;
17671
17672 Py_INCREF(Py_None); resultobj = Py_None;
17673 return resultobj;
17674 fail:
17675 return NULL;
17676 }
17677
17678
17679 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17680 PyObject *resultobj;
17681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17682 bool result;
17683 PyObject * obj0 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "self", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 result = (bool) ((arg1)->m_rightDown);
17692
17693 {
17694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17695 }
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17705 bool arg2 ;
17706 PyObject * obj0 = 0 ;
17707 PyObject * obj1 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self",(char *) "m_controlDown", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
17717 if (SWIG_arg_fail(2)) SWIG_fail;
17718 }
17719 if (arg1) (arg1)->m_controlDown = arg2;
17720
17721 Py_INCREF(Py_None); resultobj = Py_None;
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17729 PyObject *resultobj;
17730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17731 bool result;
17732 PyObject * obj0 = 0 ;
17733 char *kwnames[] = {
17734 (char *) "self", NULL
17735 };
17736
17737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 result = (bool) ((arg1)->m_controlDown);
17741
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17754 bool arg2 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char *kwnames[] = {
17758 (char *) "self",(char *) "m_shiftDown", NULL
17759 };
17760
17761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17763 if (SWIG_arg_fail(1)) SWIG_fail;
17764 {
17765 arg2 = (bool)(SWIG_As_bool(obj1));
17766 if (SWIG_arg_fail(2)) SWIG_fail;
17767 }
17768 if (arg1) (arg1)->m_shiftDown = arg2;
17769
17770 Py_INCREF(Py_None); resultobj = Py_None;
17771 return resultobj;
17772 fail:
17773 return NULL;
17774 }
17775
17776
17777 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17778 PyObject *resultobj;
17779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17780 bool result;
17781 PyObject * obj0 = 0 ;
17782 char *kwnames[] = {
17783 (char *) "self", NULL
17784 };
17785
17786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17788 if (SWIG_arg_fail(1)) SWIG_fail;
17789 result = (bool) ((arg1)->m_shiftDown);
17790
17791 {
17792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17793 }
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17803 bool arg2 ;
17804 PyObject * obj0 = 0 ;
17805 PyObject * obj1 = 0 ;
17806 char *kwnames[] = {
17807 (char *) "self",(char *) "m_altDown", NULL
17808 };
17809
17810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17812 if (SWIG_arg_fail(1)) SWIG_fail;
17813 {
17814 arg2 = (bool)(SWIG_As_bool(obj1));
17815 if (SWIG_arg_fail(2)) SWIG_fail;
17816 }
17817 if (arg1) (arg1)->m_altDown = arg2;
17818
17819 Py_INCREF(Py_None); resultobj = Py_None;
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17829 bool result;
17830 PyObject * obj0 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 result = (bool) ((arg1)->m_altDown);
17839
17840 {
17841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17842 }
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj;
17851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17852 bool arg2 ;
17853 PyObject * obj0 = 0 ;
17854 PyObject * obj1 = 0 ;
17855 char *kwnames[] = {
17856 (char *) "self",(char *) "m_metaDown", NULL
17857 };
17858
17859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17861 if (SWIG_arg_fail(1)) SWIG_fail;
17862 {
17863 arg2 = (bool)(SWIG_As_bool(obj1));
17864 if (SWIG_arg_fail(2)) SWIG_fail;
17865 }
17866 if (arg1) (arg1)->m_metaDown = arg2;
17867
17868 Py_INCREF(Py_None); resultobj = Py_None;
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj;
17877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17878 bool result;
17879 PyObject * obj0 = 0 ;
17880 char *kwnames[] = {
17881 (char *) "self", NULL
17882 };
17883
17884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(1)) SWIG_fail;
17887 result = (bool) ((arg1)->m_metaDown);
17888
17889 {
17890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj;
17900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17901 int arg2 ;
17902 PyObject * obj0 = 0 ;
17903 PyObject * obj1 = 0 ;
17904 char *kwnames[] = {
17905 (char *) "self",(char *) "m_wheelRotation", NULL
17906 };
17907
17908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 {
17912 arg2 = (int)(SWIG_As_int(obj1));
17913 if (SWIG_arg_fail(2)) SWIG_fail;
17914 }
17915 if (arg1) (arg1)->m_wheelRotation = arg2;
17916
17917 Py_INCREF(Py_None); resultobj = Py_None;
17918 return resultobj;
17919 fail:
17920 return NULL;
17921 }
17922
17923
17924 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17925 PyObject *resultobj;
17926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17927 int result;
17928 PyObject * obj0 = 0 ;
17929 char *kwnames[] = {
17930 (char *) "self", NULL
17931 };
17932
17933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17935 if (SWIG_arg_fail(1)) SWIG_fail;
17936 result = (int) ((arg1)->m_wheelRotation);
17937
17938 {
17939 resultobj = SWIG_From_int((int)(result));
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj;
17949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17950 int arg2 ;
17951 PyObject * obj0 = 0 ;
17952 PyObject * obj1 = 0 ;
17953 char *kwnames[] = {
17954 (char *) "self",(char *) "m_wheelDelta", NULL
17955 };
17956
17957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17959 if (SWIG_arg_fail(1)) SWIG_fail;
17960 {
17961 arg2 = (int)(SWIG_As_int(obj1));
17962 if (SWIG_arg_fail(2)) SWIG_fail;
17963 }
17964 if (arg1) (arg1)->m_wheelDelta = arg2;
17965
17966 Py_INCREF(Py_None); resultobj = Py_None;
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj;
17975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17976 int result;
17977 PyObject * obj0 = 0 ;
17978 char *kwnames[] = {
17979 (char *) "self", NULL
17980 };
17981
17982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17984 if (SWIG_arg_fail(1)) SWIG_fail;
17985 result = (int) ((arg1)->m_wheelDelta);
17986
17987 {
17988 resultobj = SWIG_From_int((int)(result));
17989 }
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17999 int arg2 ;
18000 PyObject * obj0 = 0 ;
18001 PyObject * obj1 = 0 ;
18002 char *kwnames[] = {
18003 (char *) "self",(char *) "m_linesPerAction", NULL
18004 };
18005
18006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18008 if (SWIG_arg_fail(1)) SWIG_fail;
18009 {
18010 arg2 = (int)(SWIG_As_int(obj1));
18011 if (SWIG_arg_fail(2)) SWIG_fail;
18012 }
18013 if (arg1) (arg1)->m_linesPerAction = arg2;
18014
18015 Py_INCREF(Py_None); resultobj = Py_None;
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj;
18024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18025 int result;
18026 PyObject * obj0 = 0 ;
18027 char *kwnames[] = {
18028 (char *) "self", NULL
18029 };
18030
18031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18033 if (SWIG_arg_fail(1)) SWIG_fail;
18034 result = (int) ((arg1)->m_linesPerAction);
18035
18036 {
18037 resultobj = SWIG_From_int((int)(result));
18038 }
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18046 PyObject *obj;
18047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18048 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18049 Py_INCREF(obj);
18050 return Py_BuildValue((char *)"");
18051 }
18052 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18053 PyObject *resultobj;
18054 int arg1 = (int) 0 ;
18055 int arg2 = (int) 0 ;
18056 wxSetCursorEvent *result;
18057 PyObject * obj0 = 0 ;
18058 PyObject * obj1 = 0 ;
18059 char *kwnames[] = {
18060 (char *) "x",(char *) "y", NULL
18061 };
18062
18063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18064 if (obj0) {
18065 {
18066 arg1 = (int)(SWIG_As_int(obj0));
18067 if (SWIG_arg_fail(1)) SWIG_fail;
18068 }
18069 }
18070 if (obj1) {
18071 {
18072 arg2 = (int)(SWIG_As_int(obj1));
18073 if (SWIG_arg_fail(2)) SWIG_fail;
18074 }
18075 }
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18079
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18093 int result;
18094 PyObject * obj0 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 resultobj = SWIG_From_int((int)(result));
18111 }
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18121 int result;
18122 PyObject * obj0 = 0 ;
18123 char *kwnames[] = {
18124 (char *) "self", NULL
18125 };
18126
18127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18129 if (SWIG_arg_fail(1)) SWIG_fail;
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18133
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 {
18138 resultobj = SWIG_From_int((int)(result));
18139 }
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj;
18148 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18149 wxCursor *arg2 = 0 ;
18150 PyObject * obj0 = 0 ;
18151 PyObject * obj1 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self",(char *) "cursor", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18161 if (SWIG_arg_fail(2)) SWIG_fail;
18162 if (arg2 == NULL) {
18163 SWIG_null_ref("wxCursor");
18164 }
18165 if (SWIG_arg_fail(2)) SWIG_fail;
18166 }
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 (arg1)->SetCursor((wxCursor const &)*arg2);
18170
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 Py_INCREF(Py_None); resultobj = Py_None;
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj;
18183 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18184 wxCursor *result;
18185 PyObject * obj0 = 0 ;
18186 char *kwnames[] = {
18187 (char *) "self", NULL
18188 };
18189
18190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18192 if (SWIG_arg_fail(1)) SWIG_fail;
18193 {
18194 PyThreadState* __tstate = wxPyBeginAllowThreads();
18195 {
18196 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18197 result = (wxCursor *) &_result_ref;
18198 }
18199
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 {
18204 wxCursor* resultptr = new wxCursor(*result);
18205 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18216 bool result;
18217 PyObject * obj0 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18228
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 {
18233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18234 }
18235 return resultobj;
18236 fail:
18237 return NULL;
18238 }
18239
18240
18241 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18242 PyObject *obj;
18243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18244 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18245 Py_INCREF(obj);
18246 return Py_BuildValue((char *)"");
18247 }
18248 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj;
18250 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18251 wxKeyEvent *result;
18252 PyObject * obj0 = 0 ;
18253 char *kwnames[] = {
18254 (char *) "keyType", NULL
18255 };
18256
18257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18258 if (obj0) {
18259 {
18260 arg1 = (wxEventType)(SWIG_As_int(obj0));
18261 if (SWIG_arg_fail(1)) SWIG_fail;
18262 }
18263 }
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18267
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj;
18280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18281 bool result;
18282 PyObject * obj0 = 0 ;
18283 char *kwnames[] = {
18284 (char *) "self", NULL
18285 };
18286
18287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18289 if (SWIG_arg_fail(1)) SWIG_fail;
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18293
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 {
18298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18299 }
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18309 bool result;
18310 PyObject * obj0 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18321
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 {
18326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18327 }
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18335 PyObject *resultobj;
18336 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18337 bool result;
18338 PyObject * obj0 = 0 ;
18339 char *kwnames[] = {
18340 (char *) "self", NULL
18341 };
18342
18343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18349
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 {
18354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18355 }
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj;
18364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18365 bool result;
18366 PyObject * obj0 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18393 bool result;
18394 PyObject * obj0 = 0 ;
18395 char *kwnames[] = {
18396 (char *) "self", NULL
18397 };
18398
18399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18401 if (SWIG_arg_fail(1)) SWIG_fail;
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18405
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 {
18410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18411 }
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18421 bool result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 {
18431 PyThreadState* __tstate = wxPyBeginAllowThreads();
18432 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18433
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18449 int result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 resultobj = SWIG_From_int((int)(result));
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 int result;
18478 PyObject * obj0 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 resultobj = SWIG_From_int((int)(result));
18495 }
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18505 unsigned int result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18533 unsigned int result;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18561 wxPoint result;
18562 PyObject * obj0 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "self", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18569 if (SWIG_arg_fail(1)) SWIG_fail;
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (arg1)->GetPosition();
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 wxPoint * resultptr;
18579 resultptr = new wxPoint((wxPoint &)(result));
18580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18581 }
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj;
18590 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18591 long *arg2 = (long *) 0 ;
18592 long *arg3 = (long *) 0 ;
18593 long temp2 ;
18594 int res2 = 0 ;
18595 long temp3 ;
18596 int res3 = 0 ;
18597 PyObject * obj0 = 0 ;
18598 char *kwnames[] = {
18599 (char *) "self", NULL
18600 };
18601
18602 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18603 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18606 if (SWIG_arg_fail(1)) SWIG_fail;
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 (arg1)->GetPosition(arg2,arg3);
18610
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 Py_INCREF(Py_None); resultobj = Py_None;
18615 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18616 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18617 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18618 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18628 int result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (int)((wxKeyEvent const *)arg1)->GetX();
18640
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 {
18645 resultobj = SWIG_From_int((int)(result));
18646 }
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj;
18655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18656 int result;
18657 PyObject * obj0 = 0 ;
18658 char *kwnames[] = {
18659 (char *) "self", NULL
18660 };
18661
18662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18664 if (SWIG_arg_fail(1)) SWIG_fail;
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = (int)((wxKeyEvent const *)arg1)->GetY();
18668
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 {
18673 resultobj = SWIG_From_int((int)(result));
18674 }
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18684 int arg2 ;
18685 PyObject * obj0 = 0 ;
18686 PyObject * obj1 = 0 ;
18687 char *kwnames[] = {
18688 (char *) "self",(char *) "m_x", NULL
18689 };
18690
18691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18693 if (SWIG_arg_fail(1)) SWIG_fail;
18694 {
18695 arg2 = (int)(SWIG_As_int(obj1));
18696 if (SWIG_arg_fail(2)) SWIG_fail;
18697 }
18698 if (arg1) (arg1)->m_x = arg2;
18699
18700 Py_INCREF(Py_None); resultobj = Py_None;
18701 return resultobj;
18702 fail:
18703 return NULL;
18704 }
18705
18706
18707 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18708 PyObject *resultobj;
18709 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18710 int result;
18711 PyObject * obj0 = 0 ;
18712 char *kwnames[] = {
18713 (char *) "self", NULL
18714 };
18715
18716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18718 if (SWIG_arg_fail(1)) SWIG_fail;
18719 result = (int) ((arg1)->m_x);
18720
18721 {
18722 resultobj = SWIG_From_int((int)(result));
18723 }
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18733 int arg2 ;
18734 PyObject * obj0 = 0 ;
18735 PyObject * obj1 = 0 ;
18736 char *kwnames[] = {
18737 (char *) "self",(char *) "m_y", NULL
18738 };
18739
18740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18742 if (SWIG_arg_fail(1)) SWIG_fail;
18743 {
18744 arg2 = (int)(SWIG_As_int(obj1));
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 }
18747 if (arg1) (arg1)->m_y = arg2;
18748
18749 Py_INCREF(Py_None); resultobj = Py_None;
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18759 int result;
18760 PyObject * obj0 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 result = (int) ((arg1)->m_y);
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_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18782 long arg2 ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char *kwnames[] = {
18786 (char *) "self",(char *) "m_keyCode", NULL
18787 };
18788
18789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18791 if (SWIG_arg_fail(1)) SWIG_fail;
18792 {
18793 arg2 = (long)(SWIG_As_long(obj1));
18794 if (SWIG_arg_fail(2)) SWIG_fail;
18795 }
18796 if (arg1) (arg1)->m_keyCode = arg2;
18797
18798 Py_INCREF(Py_None); resultobj = Py_None;
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18808 long result;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 result = (long) ((arg1)->m_keyCode);
18818
18819 {
18820 resultobj = SWIG_From_long((long)(result));
18821 }
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18831 bool arg2 ;
18832 PyObject * obj0 = 0 ;
18833 PyObject * obj1 = 0 ;
18834 char *kwnames[] = {
18835 (char *) "self",(char *) "m_controlDown", NULL
18836 };
18837
18838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18840 if (SWIG_arg_fail(1)) SWIG_fail;
18841 {
18842 arg2 = (bool)(SWIG_As_bool(obj1));
18843 if (SWIG_arg_fail(2)) SWIG_fail;
18844 }
18845 if (arg1) (arg1)->m_controlDown = arg2;
18846
18847 Py_INCREF(Py_None); resultobj = Py_None;
18848 return resultobj;
18849 fail:
18850 return NULL;
18851 }
18852
18853
18854 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18855 PyObject *resultobj;
18856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18857 bool result;
18858 PyObject * obj0 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "self", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 result = (bool) ((arg1)->m_controlDown);
18867
18868 {
18869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18870 }
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18878 PyObject *resultobj;
18879 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18880 bool arg2 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char *kwnames[] = {
18884 (char *) "self",(char *) "m_shiftDown", NULL
18885 };
18886
18887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18889 if (SWIG_arg_fail(1)) SWIG_fail;
18890 {
18891 arg2 = (bool)(SWIG_As_bool(obj1));
18892 if (SWIG_arg_fail(2)) SWIG_fail;
18893 }
18894 if (arg1) (arg1)->m_shiftDown = arg2;
18895
18896 Py_INCREF(Py_None); resultobj = Py_None;
18897 return resultobj;
18898 fail:
18899 return NULL;
18900 }
18901
18902
18903 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18904 PyObject *resultobj;
18905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18906 bool result;
18907 PyObject * obj0 = 0 ;
18908 char *kwnames[] = {
18909 (char *) "self", NULL
18910 };
18911
18912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 result = (bool) ((arg1)->m_shiftDown);
18916
18917 {
18918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18929 bool arg2 ;
18930 PyObject * obj0 = 0 ;
18931 PyObject * obj1 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self",(char *) "m_altDown", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 arg2 = (bool)(SWIG_As_bool(obj1));
18941 if (SWIG_arg_fail(2)) SWIG_fail;
18942 }
18943 if (arg1) (arg1)->m_altDown = arg2;
18944
18945 Py_INCREF(Py_None); resultobj = Py_None;
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18955 bool result;
18956 PyObject * obj0 = 0 ;
18957 char *kwnames[] = {
18958 (char *) "self", NULL
18959 };
18960
18961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(1)) SWIG_fail;
18964 result = (bool) ((arg1)->m_altDown);
18965
18966 {
18967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18968 }
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18978 bool arg2 ;
18979 PyObject * obj0 = 0 ;
18980 PyObject * obj1 = 0 ;
18981 char *kwnames[] = {
18982 (char *) "self",(char *) "m_metaDown", NULL
18983 };
18984
18985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18987 if (SWIG_arg_fail(1)) SWIG_fail;
18988 {
18989 arg2 = (bool)(SWIG_As_bool(obj1));
18990 if (SWIG_arg_fail(2)) SWIG_fail;
18991 }
18992 if (arg1) (arg1)->m_metaDown = arg2;
18993
18994 Py_INCREF(Py_None); resultobj = Py_None;
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj;
19003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19004 bool result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 result = (bool) ((arg1)->m_metaDown);
19014
19015 {
19016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19017 }
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19025 PyObject *resultobj;
19026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19027 bool arg2 ;
19028 PyObject * obj0 = 0 ;
19029 PyObject * obj1 = 0 ;
19030 char *kwnames[] = {
19031 (char *) "self",(char *) "m_scanCode", NULL
19032 };
19033
19034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19036 if (SWIG_arg_fail(1)) SWIG_fail;
19037 {
19038 arg2 = (bool)(SWIG_As_bool(obj1));
19039 if (SWIG_arg_fail(2)) SWIG_fail;
19040 }
19041 if (arg1) (arg1)->m_scanCode = arg2;
19042
19043 Py_INCREF(Py_None); resultobj = Py_None;
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj;
19052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19053 bool result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 result = (bool) ((arg1)->m_scanCode);
19063
19064 {
19065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19066 }
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19074 PyObject *resultobj;
19075 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19076 unsigned int arg2 ;
19077 PyObject * obj0 = 0 ;
19078 PyObject * obj1 = 0 ;
19079 char *kwnames[] = {
19080 (char *) "self",(char *) "m_rawCode", NULL
19081 };
19082
19083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19085 if (SWIG_arg_fail(1)) SWIG_fail;
19086 {
19087 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19088 if (SWIG_arg_fail(2)) SWIG_fail;
19089 }
19090 if (arg1) (arg1)->m_rawCode = arg2;
19091
19092 Py_INCREF(Py_None); resultobj = Py_None;
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj;
19101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19102 unsigned int result;
19103 PyObject * obj0 = 0 ;
19104 char *kwnames[] = {
19105 (char *) "self", NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19110 if (SWIG_arg_fail(1)) SWIG_fail;
19111 result = (unsigned int) ((arg1)->m_rawCode);
19112
19113 {
19114 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19115 }
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19125 unsigned int arg2 ;
19126 PyObject * obj0 = 0 ;
19127 PyObject * obj1 = 0 ;
19128 char *kwnames[] = {
19129 (char *) "self",(char *) "m_rawFlags", NULL
19130 };
19131
19132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19134 if (SWIG_arg_fail(1)) SWIG_fail;
19135 {
19136 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19137 if (SWIG_arg_fail(2)) SWIG_fail;
19138 }
19139 if (arg1) (arg1)->m_rawFlags = arg2;
19140
19141 Py_INCREF(Py_None); resultobj = Py_None;
19142 return resultobj;
19143 fail:
19144 return NULL;
19145 }
19146
19147
19148 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19149 PyObject *resultobj;
19150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19151 unsigned int result;
19152 PyObject * obj0 = 0 ;
19153 char *kwnames[] = {
19154 (char *) "self", NULL
19155 };
19156
19157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19159 if (SWIG_arg_fail(1)) SWIG_fail;
19160 result = (unsigned int) ((arg1)->m_rawFlags);
19161
19162 {
19163 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19172 PyObject *obj;
19173 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19174 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19175 Py_INCREF(obj);
19176 return Py_BuildValue((char *)"");
19177 }
19178 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj;
19180 wxSize const &arg1_defvalue = wxDefaultSize ;
19181 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19182 int arg2 = (int) 0 ;
19183 wxSizeEvent *result;
19184 wxSize temp1 ;
19185 PyObject * obj0 = 0 ;
19186 PyObject * obj1 = 0 ;
19187 char *kwnames[] = {
19188 (char *) "sz",(char *) "winid", NULL
19189 };
19190
19191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19192 if (obj0) {
19193 {
19194 arg1 = &temp1;
19195 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19196 }
19197 }
19198 if (obj1) {
19199 {
19200 arg2 = (int)(SWIG_As_int(obj1));
19201 if (SWIG_arg_fail(2)) SWIG_fail;
19202 }
19203 }
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19207
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19219 PyObject *resultobj;
19220 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19221 wxSize result;
19222 PyObject * obj0 = 0 ;
19223 char *kwnames[] = {
19224 (char *) "self", NULL
19225 };
19226
19227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19229 if (SWIG_arg_fail(1)) SWIG_fail;
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 result = ((wxSizeEvent const *)arg1)->GetSize();
19233
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 {
19238 wxSize * resultptr;
19239 resultptr = new wxSize((wxSize &)(result));
19240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19241 }
19242 return resultobj;
19243 fail:
19244 return NULL;
19245 }
19246
19247
19248 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19249 PyObject *resultobj;
19250 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19251 wxRect result;
19252 PyObject * obj0 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "self", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19259 if (SWIG_arg_fail(1)) SWIG_fail;
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 result = ((wxSizeEvent const *)arg1)->GetRect();
19263
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 {
19268 wxRect * resultptr;
19269 resultptr = new wxRect((wxRect &)(result));
19270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19281 wxRect arg2 ;
19282 PyObject * obj0 = 0 ;
19283 PyObject * obj1 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "self",(char *) "rect", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19290 if (SWIG_arg_fail(1)) SWIG_fail;
19291 {
19292 wxRect * argp;
19293 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19294 if (SWIG_arg_fail(2)) SWIG_fail;
19295 if (argp == NULL) {
19296 SWIG_null_ref("wxRect");
19297 }
19298 if (SWIG_arg_fail(2)) SWIG_fail;
19299 arg2 = *argp;
19300 }
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 (arg1)->SetRect(arg2);
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 Py_INCREF(Py_None); resultobj = Py_None;
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19316 PyObject *resultobj;
19317 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19318 wxSize arg2 ;
19319 PyObject * obj0 = 0 ;
19320 PyObject * obj1 = 0 ;
19321 char *kwnames[] = {
19322 (char *) "self",(char *) "size", NULL
19323 };
19324
19325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19327 if (SWIG_arg_fail(1)) SWIG_fail;
19328 {
19329 wxSize * argp;
19330 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19331 if (SWIG_arg_fail(2)) SWIG_fail;
19332 if (argp == NULL) {
19333 SWIG_null_ref("wxSize");
19334 }
19335 if (SWIG_arg_fail(2)) SWIG_fail;
19336 arg2 = *argp;
19337 }
19338 {
19339 PyThreadState* __tstate = wxPyBeginAllowThreads();
19340 wxSizeEvent_SetSize(arg1,arg2);
19341
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 Py_INCREF(Py_None); resultobj = Py_None;
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19353 PyObject *resultobj;
19354 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19355 wxSize *arg2 = (wxSize *) 0 ;
19356 PyObject * obj0 = 0 ;
19357 PyObject * obj1 = 0 ;
19358 char *kwnames[] = {
19359 (char *) "self",(char *) "m_size", NULL
19360 };
19361
19362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19364 if (SWIG_arg_fail(1)) SWIG_fail;
19365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19366 if (SWIG_arg_fail(2)) SWIG_fail;
19367 if (arg1) (arg1)->m_size = *arg2;
19368
19369 Py_INCREF(Py_None); resultobj = Py_None;
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj;
19378 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19379 wxSize *result;
19380 PyObject * obj0 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "self", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19387 if (SWIG_arg_fail(1)) SWIG_fail;
19388 result = (wxSize *)& ((arg1)->m_size);
19389
19390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj;
19399 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19400 wxRect *arg2 = (wxRect *) 0 ;
19401 PyObject * obj0 = 0 ;
19402 PyObject * obj1 = 0 ;
19403 char *kwnames[] = {
19404 (char *) "self",(char *) "m_rect", NULL
19405 };
19406
19407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19409 if (SWIG_arg_fail(1)) SWIG_fail;
19410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19411 if (SWIG_arg_fail(2)) SWIG_fail;
19412 if (arg1) (arg1)->m_rect = *arg2;
19413
19414 Py_INCREF(Py_None); resultobj = Py_None;
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj;
19423 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19424 wxRect *result;
19425 PyObject * obj0 = 0 ;
19426 char *kwnames[] = {
19427 (char *) "self", NULL
19428 };
19429
19430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19432 if (SWIG_arg_fail(1)) SWIG_fail;
19433 result = (wxRect *)& ((arg1)->m_rect);
19434
19435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19436 return resultobj;
19437 fail:
19438 return NULL;
19439 }
19440
19441
19442 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19443 PyObject *obj;
19444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19445 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19446 Py_INCREF(obj);
19447 return Py_BuildValue((char *)"");
19448 }
19449 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj;
19451 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19452 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19453 int arg2 = (int) 0 ;
19454 wxMoveEvent *result;
19455 wxPoint temp1 ;
19456 PyObject * obj0 = 0 ;
19457 PyObject * obj1 = 0 ;
19458 char *kwnames[] = {
19459 (char *) "pos",(char *) "winid", NULL
19460 };
19461
19462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19463 if (obj0) {
19464 {
19465 arg1 = &temp1;
19466 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19467 }
19468 }
19469 if (obj1) {
19470 {
19471 arg2 = (int)(SWIG_As_int(obj1));
19472 if (SWIG_arg_fail(2)) SWIG_fail;
19473 }
19474 }
19475 {
19476 PyThreadState* __tstate = wxPyBeginAllowThreads();
19477 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19478
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj;
19491 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19492 wxPoint result;
19493 PyObject * obj0 = 0 ;
19494 char *kwnames[] = {
19495 (char *) "self", NULL
19496 };
19497
19498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19500 if (SWIG_arg_fail(1)) SWIG_fail;
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 result = ((wxMoveEvent const *)arg1)->GetPosition();
19504
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 {
19509 wxPoint * resultptr;
19510 resultptr = new wxPoint((wxPoint &)(result));
19511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19512 }
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19520 PyObject *resultobj;
19521 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19522 wxRect result;
19523 PyObject * obj0 = 0 ;
19524 char *kwnames[] = {
19525 (char *) "self", NULL
19526 };
19527
19528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19530 if (SWIG_arg_fail(1)) SWIG_fail;
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = ((wxMoveEvent const *)arg1)->GetRect();
19534
19535 wxPyEndAllowThreads(__tstate);
19536 if (PyErr_Occurred()) SWIG_fail;
19537 }
19538 {
19539 wxRect * resultptr;
19540 resultptr = new wxRect((wxRect &)(result));
19541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19542 }
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19550 PyObject *resultobj;
19551 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19552 wxRect *arg2 = 0 ;
19553 wxRect temp2 ;
19554 PyObject * obj0 = 0 ;
19555 PyObject * obj1 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "self",(char *) "rect", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 {
19564 arg2 = &temp2;
19565 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19566 }
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 (arg1)->SetRect((wxRect const &)*arg2);
19570
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 Py_INCREF(Py_None); resultobj = Py_None;
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj;
19583 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19584 wxPoint *arg2 = 0 ;
19585 wxPoint temp2 ;
19586 PyObject * obj0 = 0 ;
19587 PyObject * obj1 = 0 ;
19588 char *kwnames[] = {
19589 (char *) "self",(char *) "pos", NULL
19590 };
19591
19592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19594 if (SWIG_arg_fail(1)) SWIG_fail;
19595 {
19596 arg2 = &temp2;
19597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19598 }
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 (arg1)->SetPosition((wxPoint const &)*arg2);
19602
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 Py_INCREF(Py_None); resultobj = Py_None;
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19614 PyObject *obj;
19615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19616 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19617 Py_INCREF(obj);
19618 return Py_BuildValue((char *)"");
19619 }
19620 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19621 PyObject *resultobj;
19622 int arg1 = (int) 0 ;
19623 wxPaintEvent *result;
19624 PyObject * obj0 = 0 ;
19625 char *kwnames[] = {
19626 (char *) "Id", NULL
19627 };
19628
19629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19630 if (obj0) {
19631 {
19632 arg1 = (int)(SWIG_As_int(obj0));
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 }
19635 }
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19639
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19644 return resultobj;
19645 fail:
19646 return NULL;
19647 }
19648
19649
19650 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19651 PyObject *obj;
19652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19653 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19654 Py_INCREF(obj);
19655 return Py_BuildValue((char *)"");
19656 }
19657 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19658 PyObject *resultobj;
19659 int arg1 = (int) 0 ;
19660 wxNcPaintEvent *result;
19661 PyObject * obj0 = 0 ;
19662 char *kwnames[] = {
19663 (char *) "winid", NULL
19664 };
19665
19666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19667 if (obj0) {
19668 {
19669 arg1 = (int)(SWIG_As_int(obj0));
19670 if (SWIG_arg_fail(1)) SWIG_fail;
19671 }
19672 }
19673 {
19674 PyThreadState* __tstate = wxPyBeginAllowThreads();
19675 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19676
19677 wxPyEndAllowThreads(__tstate);
19678 if (PyErr_Occurred()) SWIG_fail;
19679 }
19680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19681 return resultobj;
19682 fail:
19683 return NULL;
19684 }
19685
19686
19687 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19688 PyObject *obj;
19689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19690 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19691 Py_INCREF(obj);
19692 return Py_BuildValue((char *)"");
19693 }
19694 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19695 PyObject *resultobj;
19696 int arg1 = (int) 0 ;
19697 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19698 wxEraseEvent *result;
19699 PyObject * obj0 = 0 ;
19700 PyObject * obj1 = 0 ;
19701 char *kwnames[] = {
19702 (char *) "Id",(char *) "dc", NULL
19703 };
19704
19705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19706 if (obj0) {
19707 {
19708 arg1 = (int)(SWIG_As_int(obj0));
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 }
19711 }
19712 if (obj1) {
19713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19714 if (SWIG_arg_fail(2)) SWIG_fail;
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19731 PyObject *resultobj;
19732 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19733 wxDC *result;
19734 PyObject * obj0 = 0 ;
19735 char *kwnames[] = {
19736 (char *) "self", NULL
19737 };
19738
19739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19741 if (SWIG_arg_fail(1)) SWIG_fail;
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19745
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 {
19750 resultobj = wxPyMake_wxObject(result, 0);
19751 }
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19759 PyObject *obj;
19760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19761 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19762 Py_INCREF(obj);
19763 return Py_BuildValue((char *)"");
19764 }
19765 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19768 int arg2 = (int) 0 ;
19769 wxFocusEvent *result;
19770 PyObject * obj0 = 0 ;
19771 PyObject * obj1 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "type",(char *) "winid", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19777 if (obj0) {
19778 {
19779 arg1 = (wxEventType)(SWIG_As_int(obj0));
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 }
19782 }
19783 if (obj1) {
19784 {
19785 arg2 = (int)(SWIG_As_int(obj1));
19786 if (SWIG_arg_fail(2)) SWIG_fail;
19787 }
19788 }
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19792
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19804 PyObject *resultobj;
19805 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19806 wxWindow *result;
19807 PyObject * obj0 = 0 ;
19808 char *kwnames[] = {
19809 (char *) "self", NULL
19810 };
19811
19812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19814 if (SWIG_arg_fail(1)) SWIG_fail;
19815 {
19816 PyThreadState* __tstate = wxPyBeginAllowThreads();
19817 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19818
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 {
19823 resultobj = wxPyMake_wxObject(result, 0);
19824 }
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19834 wxWindow *arg2 = (wxWindow *) 0 ;
19835 PyObject * obj0 = 0 ;
19836 PyObject * obj1 = 0 ;
19837 char *kwnames[] = {
19838 (char *) "self",(char *) "win", NULL
19839 };
19840
19841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19843 if (SWIG_arg_fail(1)) SWIG_fail;
19844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19845 if (SWIG_arg_fail(2)) SWIG_fail;
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 (arg1)->SetWindow(arg2);
19849
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 Py_INCREF(Py_None); resultobj = Py_None;
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19861 PyObject *obj;
19862 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19863 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19864 Py_INCREF(obj);
19865 return Py_BuildValue((char *)"");
19866 }
19867 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj;
19869 wxWindow *arg1 = (wxWindow *) NULL ;
19870 wxChildFocusEvent *result;
19871 PyObject * obj0 = 0 ;
19872 char *kwnames[] = {
19873 (char *) "win", NULL
19874 };
19875
19876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19877 if (obj0) {
19878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19879 if (SWIG_arg_fail(1)) SWIG_fail;
19880 }
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19884
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19889 return resultobj;
19890 fail:
19891 return NULL;
19892 }
19893
19894
19895 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19896 PyObject *resultobj;
19897 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19898 wxWindow *result;
19899 PyObject * obj0 = 0 ;
19900 char *kwnames[] = {
19901 (char *) "self", NULL
19902 };
19903
19904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19906 if (SWIG_arg_fail(1)) SWIG_fail;
19907 {
19908 PyThreadState* __tstate = wxPyBeginAllowThreads();
19909 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19910
19911 wxPyEndAllowThreads(__tstate);
19912 if (PyErr_Occurred()) SWIG_fail;
19913 }
19914 {
19915 resultobj = wxPyMake_wxObject(result, 0);
19916 }
19917 return resultobj;
19918 fail:
19919 return NULL;
19920 }
19921
19922
19923 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19924 PyObject *obj;
19925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19926 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19927 Py_INCREF(obj);
19928 return Py_BuildValue((char *)"");
19929 }
19930 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19933 bool arg2 = (bool) true ;
19934 int arg3 = (int) 0 ;
19935 wxActivateEvent *result;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 PyObject * obj2 = 0 ;
19939 char *kwnames[] = {
19940 (char *) "type",(char *) "active",(char *) "Id", NULL
19941 };
19942
19943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19944 if (obj0) {
19945 {
19946 arg1 = (wxEventType)(SWIG_As_int(obj0));
19947 if (SWIG_arg_fail(1)) SWIG_fail;
19948 }
19949 }
19950 if (obj1) {
19951 {
19952 arg2 = (bool)(SWIG_As_bool(obj1));
19953 if (SWIG_arg_fail(2)) SWIG_fail;
19954 }
19955 }
19956 if (obj2) {
19957 {
19958 arg3 = (int)(SWIG_As_int(obj2));
19959 if (SWIG_arg_fail(3)) SWIG_fail;
19960 }
19961 }
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19979 bool result;
19980 PyObject * obj0 = 0 ;
19981 char *kwnames[] = {
19982 (char *) "self", NULL
19983 };
19984
19985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19987 if (SWIG_arg_fail(1)) SWIG_fail;
19988 {
19989 PyThreadState* __tstate = wxPyBeginAllowThreads();
19990 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19991
19992 wxPyEndAllowThreads(__tstate);
19993 if (PyErr_Occurred()) SWIG_fail;
19994 }
19995 {
19996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19997 }
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20005 PyObject *obj;
20006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20007 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20008 Py_INCREF(obj);
20009 return Py_BuildValue((char *)"");
20010 }
20011 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20012 PyObject *resultobj;
20013 int arg1 = (int) 0 ;
20014 wxInitDialogEvent *result;
20015 PyObject * obj0 = 0 ;
20016 char *kwnames[] = {
20017 (char *) "Id", NULL
20018 };
20019
20020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20021 if (obj0) {
20022 {
20023 arg1 = (int)(SWIG_As_int(obj0));
20024 if (SWIG_arg_fail(1)) SWIG_fail;
20025 }
20026 }
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20030
20031 wxPyEndAllowThreads(__tstate);
20032 if (PyErr_Occurred()) SWIG_fail;
20033 }
20034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20042 PyObject *obj;
20043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20044 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20045 Py_INCREF(obj);
20046 return Py_BuildValue((char *)"");
20047 }
20048 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20049 PyObject *resultobj;
20050 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20051 int arg2 = (int) 0 ;
20052 wxMenu *arg3 = (wxMenu *) NULL ;
20053 wxMenuEvent *result;
20054 PyObject * obj0 = 0 ;
20055 PyObject * obj1 = 0 ;
20056 PyObject * obj2 = 0 ;
20057 char *kwnames[] = {
20058 (char *) "type",(char *) "winid",(char *) "menu", NULL
20059 };
20060
20061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20062 if (obj0) {
20063 {
20064 arg1 = (wxEventType)(SWIG_As_int(obj0));
20065 if (SWIG_arg_fail(1)) SWIG_fail;
20066 }
20067 }
20068 if (obj1) {
20069 {
20070 arg2 = (int)(SWIG_As_int(obj1));
20071 if (SWIG_arg_fail(2)) SWIG_fail;
20072 }
20073 }
20074 if (obj2) {
20075 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20076 if (SWIG_arg_fail(3)) SWIG_fail;
20077 }
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20081
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20093 PyObject *resultobj;
20094 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20095 int result;
20096 PyObject * obj0 = 0 ;
20097 char *kwnames[] = {
20098 (char *) "self", NULL
20099 };
20100
20101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20103 if (SWIG_arg_fail(1)) SWIG_fail;
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20107
20108 wxPyEndAllowThreads(__tstate);
20109 if (PyErr_Occurred()) SWIG_fail;
20110 }
20111 {
20112 resultobj = SWIG_From_int((int)(result));
20113 }
20114 return resultobj;
20115 fail:
20116 return NULL;
20117 }
20118
20119
20120 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20121 PyObject *resultobj;
20122 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20123 bool result;
20124 PyObject * obj0 = 0 ;
20125 char *kwnames[] = {
20126 (char *) "self", NULL
20127 };
20128
20129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20131 if (SWIG_arg_fail(1)) SWIG_fail;
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20135
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 {
20140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20141 }
20142 return resultobj;
20143 fail:
20144 return NULL;
20145 }
20146
20147
20148 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20149 PyObject *resultobj;
20150 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20151 wxMenu *result;
20152 PyObject * obj0 = 0 ;
20153 char *kwnames[] = {
20154 (char *) "self", NULL
20155 };
20156
20157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20159 if (SWIG_arg_fail(1)) SWIG_fail;
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = wxPyMake_wxObject(result, 0);
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20177 PyObject *obj;
20178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20179 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20180 Py_INCREF(obj);
20181 return Py_BuildValue((char *)"");
20182 }
20183 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20184 PyObject *resultobj;
20185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20186 int arg2 = (int) 0 ;
20187 wxCloseEvent *result;
20188 PyObject * obj0 = 0 ;
20189 PyObject * obj1 = 0 ;
20190 char *kwnames[] = {
20191 (char *) "type",(char *) "winid", NULL
20192 };
20193
20194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20195 if (obj0) {
20196 {
20197 arg1 = (wxEventType)(SWIG_As_int(obj0));
20198 if (SWIG_arg_fail(1)) SWIG_fail;
20199 }
20200 }
20201 if (obj1) {
20202 {
20203 arg2 = (int)(SWIG_As_int(obj1));
20204 if (SWIG_arg_fail(2)) SWIG_fail;
20205 }
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj;
20223 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20224 bool arg2 ;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 char *kwnames[] = {
20228 (char *) "self",(char *) "logOff", NULL
20229 };
20230
20231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20233 if (SWIG_arg_fail(1)) SWIG_fail;
20234 {
20235 arg2 = (bool)(SWIG_As_bool(obj1));
20236 if (SWIG_arg_fail(2)) SWIG_fail;
20237 }
20238 {
20239 PyThreadState* __tstate = wxPyBeginAllowThreads();
20240 (arg1)->SetLoggingOff(arg2);
20241
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 Py_INCREF(Py_None); resultobj = Py_None;
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj;
20254 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20255 bool result;
20256 PyObject * obj0 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "self", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20263 if (SWIG_arg_fail(1)) SWIG_fail;
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20267
20268 wxPyEndAllowThreads(__tstate);
20269 if (PyErr_Occurred()) SWIG_fail;
20270 }
20271 {
20272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20273 }
20274 return resultobj;
20275 fail:
20276 return NULL;
20277 }
20278
20279
20280 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20281 PyObject *resultobj;
20282 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20283 bool arg2 = (bool) true ;
20284 PyObject * obj0 = 0 ;
20285 PyObject * obj1 = 0 ;
20286 char *kwnames[] = {
20287 (char *) "self",(char *) "veto", NULL
20288 };
20289
20290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20292 if (SWIG_arg_fail(1)) SWIG_fail;
20293 if (obj1) {
20294 {
20295 arg2 = (bool)(SWIG_As_bool(obj1));
20296 if (SWIG_arg_fail(2)) SWIG_fail;
20297 }
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 (arg1)->Veto(arg2);
20302
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 Py_INCREF(Py_None); resultobj = Py_None;
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20314 PyObject *resultobj;
20315 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20316 bool arg2 ;
20317 PyObject * obj0 = 0 ;
20318 PyObject * obj1 = 0 ;
20319 char *kwnames[] = {
20320 (char *) "self",(char *) "canVeto", NULL
20321 };
20322
20323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20325 if (SWIG_arg_fail(1)) SWIG_fail;
20326 {
20327 arg2 = (bool)(SWIG_As_bool(obj1));
20328 if (SWIG_arg_fail(2)) SWIG_fail;
20329 }
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 (arg1)->SetCanVeto(arg2);
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 Py_INCREF(Py_None); resultobj = Py_None;
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20345 PyObject *resultobj;
20346 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20347 bool result;
20348 PyObject * obj0 = 0 ;
20349 char *kwnames[] = {
20350 (char *) "self", NULL
20351 };
20352
20353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20355 if (SWIG_arg_fail(1)) SWIG_fail;
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20359
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 {
20364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20365 }
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj;
20374 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20375 bool result;
20376 PyObject * obj0 = 0 ;
20377 char *kwnames[] = {
20378 (char *) "self", NULL
20379 };
20380
20381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20383 if (SWIG_arg_fail(1)) SWIG_fail;
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20387
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 {
20392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20401 PyObject *obj;
20402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20403 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20404 Py_INCREF(obj);
20405 return Py_BuildValue((char *)"");
20406 }
20407 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20408 PyObject *resultobj;
20409 int arg1 = (int) 0 ;
20410 bool arg2 = (bool) false ;
20411 wxShowEvent *result;
20412 PyObject * obj0 = 0 ;
20413 PyObject * obj1 = 0 ;
20414 char *kwnames[] = {
20415 (char *) "winid",(char *) "show", NULL
20416 };
20417
20418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20419 if (obj0) {
20420 {
20421 arg1 = (int)(SWIG_As_int(obj0));
20422 if (SWIG_arg_fail(1)) SWIG_fail;
20423 }
20424 }
20425 if (obj1) {
20426 {
20427 arg2 = (bool)(SWIG_As_bool(obj1));
20428 if (SWIG_arg_fail(2)) SWIG_fail;
20429 }
20430 }
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20434
20435 wxPyEndAllowThreads(__tstate);
20436 if (PyErr_Occurred()) SWIG_fail;
20437 }
20438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj;
20447 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20448 bool arg2 ;
20449 PyObject * obj0 = 0 ;
20450 PyObject * obj1 = 0 ;
20451 char *kwnames[] = {
20452 (char *) "self",(char *) "show", NULL
20453 };
20454
20455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20457 if (SWIG_arg_fail(1)) SWIG_fail;
20458 {
20459 arg2 = (bool)(SWIG_As_bool(obj1));
20460 if (SWIG_arg_fail(2)) SWIG_fail;
20461 }
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 (arg1)->SetShow(arg2);
20465
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 Py_INCREF(Py_None); resultobj = Py_None;
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj;
20478 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20479 bool result;
20480 PyObject * obj0 = 0 ;
20481 char *kwnames[] = {
20482 (char *) "self", NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20487 if (SWIG_arg_fail(1)) SWIG_fail;
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20491
20492 wxPyEndAllowThreads(__tstate);
20493 if (PyErr_Occurred()) SWIG_fail;
20494 }
20495 {
20496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20505 PyObject *obj;
20506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20507 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20508 Py_INCREF(obj);
20509 return Py_BuildValue((char *)"");
20510 }
20511 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj;
20513 int arg1 = (int) 0 ;
20514 bool arg2 = (bool) true ;
20515 wxIconizeEvent *result;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 char *kwnames[] = {
20519 (char *) "id",(char *) "iconized", NULL
20520 };
20521
20522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20523 if (obj0) {
20524 {
20525 arg1 = (int)(SWIG_As_int(obj0));
20526 if (SWIG_arg_fail(1)) SWIG_fail;
20527 }
20528 }
20529 if (obj1) {
20530 {
20531 arg2 = (bool)(SWIG_As_bool(obj1));
20532 if (SWIG_arg_fail(2)) SWIG_fail;
20533 }
20534 }
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20550 PyObject *resultobj;
20551 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20552 bool result;
20553 PyObject * obj0 = 0 ;
20554 char *kwnames[] = {
20555 (char *) "self", NULL
20556 };
20557
20558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20560 if (SWIG_arg_fail(1)) SWIG_fail;
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)(arg1)->Iconized();
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20578 PyObject *obj;
20579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20580 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20581 Py_INCREF(obj);
20582 return Py_BuildValue((char *)"");
20583 }
20584 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20585 PyObject *resultobj;
20586 int arg1 = (int) 0 ;
20587 wxMaximizeEvent *result;
20588 PyObject * obj0 = 0 ;
20589 char *kwnames[] = {
20590 (char *) "id", NULL
20591 };
20592
20593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20594 if (obj0) {
20595 {
20596 arg1 = (int)(SWIG_As_int(obj0));
20597 if (SWIG_arg_fail(1)) SWIG_fail;
20598 }
20599 }
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20603
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20615 PyObject *obj;
20616 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20617 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20618 Py_INCREF(obj);
20619 return Py_BuildValue((char *)"");
20620 }
20621 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj;
20623 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20624 wxPoint result;
20625 PyObject * obj0 = 0 ;
20626 char *kwnames[] = {
20627 (char *) "self", NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20632 if (SWIG_arg_fail(1)) SWIG_fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (arg1)->GetPosition();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 {
20641 wxPoint * resultptr;
20642 resultptr = new wxPoint((wxPoint &)(result));
20643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj;
20653 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20654 int result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "self", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20662 if (SWIG_arg_fail(1)) SWIG_fail;
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = (int)(arg1)->GetNumberOfFiles();
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 resultobj = SWIG_From_int((int)(result));
20672 }
20673 return resultobj;
20674 fail:
20675 return NULL;
20676 }
20677
20678
20679 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20680 PyObject *resultobj;
20681 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20682 PyObject *result;
20683 PyObject * obj0 = 0 ;
20684 char *kwnames[] = {
20685 (char *) "self", NULL
20686 };
20687
20688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20690 if (SWIG_arg_fail(1)) SWIG_fail;
20691 {
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20694
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 resultobj = result;
20699 return resultobj;
20700 fail:
20701 return NULL;
20702 }
20703
20704
20705 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20706 PyObject *obj;
20707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20708 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20709 Py_INCREF(obj);
20710 return Py_BuildValue((char *)"");
20711 }
20712 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20713 PyObject *resultobj;
20714 int arg1 = (int) 0 ;
20715 wxUpdateUIEvent *result;
20716 PyObject * obj0 = 0 ;
20717 char *kwnames[] = {
20718 (char *) "commandId", NULL
20719 };
20720
20721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20722 if (obj0) {
20723 {
20724 arg1 = (int)(SWIG_As_int(obj0));
20725 if (SWIG_arg_fail(1)) SWIG_fail;
20726 }
20727 }
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20731
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj;
20744 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20745 bool result;
20746 PyObject * obj0 = 0 ;
20747 char *kwnames[] = {
20748 (char *) "self", NULL
20749 };
20750
20751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20753 if (SWIG_arg_fail(1)) SWIG_fail;
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20757
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 {
20762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20763 }
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20771 PyObject *resultobj;
20772 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20773 bool result;
20774 PyObject * obj0 = 0 ;
20775 char *kwnames[] = {
20776 (char *) "self", NULL
20777 };
20778
20779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20781 if (SWIG_arg_fail(1)) SWIG_fail;
20782 {
20783 PyThreadState* __tstate = wxPyBeginAllowThreads();
20784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20785
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 {
20790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20791 }
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20801 wxString result;
20802 PyObject * obj0 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "self", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 {
20818 #if wxUSE_UNICODE
20819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20820 #else
20821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20822 #endif
20823 }
20824 return resultobj;
20825 fail:
20826 return NULL;
20827 }
20828
20829
20830 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20831 PyObject *resultobj;
20832 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20833 bool result;
20834 PyObject * obj0 = 0 ;
20835 char *kwnames[] = {
20836 (char *) "self", NULL
20837 };
20838
20839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20841 if (SWIG_arg_fail(1)) SWIG_fail;
20842 {
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20845
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20861 bool result;
20862 PyObject * obj0 = 0 ;
20863 char *kwnames[] = {
20864 (char *) "self", NULL
20865 };
20866
20867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20869 if (SWIG_arg_fail(1)) SWIG_fail;
20870 {
20871 PyThreadState* __tstate = wxPyBeginAllowThreads();
20872 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20873
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 {
20878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20879 }
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj;
20888 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20889 bool result;
20890 PyObject * obj0 = 0 ;
20891 char *kwnames[] = {
20892 (char *) "self", NULL
20893 };
20894
20895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20897 if (SWIG_arg_fail(1)) SWIG_fail;
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 {
20906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20917 bool arg2 ;
20918 PyObject * obj0 = 0 ;
20919 PyObject * obj1 = 0 ;
20920 char *kwnames[] = {
20921 (char *) "self",(char *) "check", NULL
20922 };
20923
20924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20926 if (SWIG_arg_fail(1)) SWIG_fail;
20927 {
20928 arg2 = (bool)(SWIG_As_bool(obj1));
20929 if (SWIG_arg_fail(2)) SWIG_fail;
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 (arg1)->Check(arg2);
20934
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 Py_INCREF(Py_None); resultobj = Py_None;
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20946 PyObject *resultobj;
20947 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20948 bool arg2 ;
20949 PyObject * obj0 = 0 ;
20950 PyObject * obj1 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "self",(char *) "enable", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20957 if (SWIG_arg_fail(1)) SWIG_fail;
20958 {
20959 arg2 = (bool)(SWIG_As_bool(obj1));
20960 if (SWIG_arg_fail(2)) SWIG_fail;
20961 }
20962 {
20963 PyThreadState* __tstate = wxPyBeginAllowThreads();
20964 (arg1)->Enable(arg2);
20965
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 Py_INCREF(Py_None); resultobj = Py_None;
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20977 PyObject *resultobj;
20978 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20979 wxString *arg2 = 0 ;
20980 bool temp2 = false ;
20981 PyObject * obj0 = 0 ;
20982 PyObject * obj1 = 0 ;
20983 char *kwnames[] = {
20984 (char *) "self",(char *) "text", NULL
20985 };
20986
20987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20989 if (SWIG_arg_fail(1)) SWIG_fail;
20990 {
20991 arg2 = wxString_in_helper(obj1);
20992 if (arg2 == NULL) SWIG_fail;
20993 temp2 = true;
20994 }
20995 {
20996 PyThreadState* __tstate = wxPyBeginAllowThreads();
20997 (arg1)->SetText((wxString const &)*arg2);
20998
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 Py_INCREF(Py_None); resultobj = Py_None;
21003 {
21004 if (temp2)
21005 delete arg2;
21006 }
21007 return resultobj;
21008 fail:
21009 {
21010 if (temp2)
21011 delete arg2;
21012 }
21013 return NULL;
21014 }
21015
21016
21017 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj;
21019 long arg1 ;
21020 PyObject * obj0 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "updateInterval", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21026 {
21027 arg1 = (long)(SWIG_As_long(obj0));
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 }
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 wxUpdateUIEvent::SetUpdateInterval(arg1);
21033
21034 wxPyEndAllowThreads(__tstate);
21035 if (PyErr_Occurred()) SWIG_fail;
21036 }
21037 Py_INCREF(Py_None); resultobj = Py_None;
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj;
21046 long result;
21047 char *kwnames[] = {
21048 NULL
21049 };
21050
21051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21055
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 {
21060 resultobj = SWIG_From_long((long)(result));
21061 }
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj;
21070 wxWindow *arg1 = (wxWindow *) 0 ;
21071 bool result;
21072 PyObject * obj0 = 0 ;
21073 char *kwnames[] = {
21074 (char *) "win", NULL
21075 };
21076
21077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21079 if (SWIG_arg_fail(1)) SWIG_fail;
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 {
21088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21089 }
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj;
21098 char *kwnames[] = {
21099 NULL
21100 };
21101
21102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 wxUpdateUIEvent::ResetUpdateTime();
21106
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 Py_INCREF(Py_None); resultobj = Py_None;
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21118 PyObject *resultobj;
21119 wxUpdateUIMode arg1 ;
21120 PyObject * obj0 = 0 ;
21121 char *kwnames[] = {
21122 (char *) "mode", NULL
21123 };
21124
21125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21126 {
21127 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21128 if (SWIG_arg_fail(1)) SWIG_fail;
21129 }
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 Py_INCREF(Py_None); resultobj = Py_None;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21145 PyObject *resultobj;
21146 wxUpdateUIMode result;
21147 char *kwnames[] = {
21148 NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21155
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 resultobj = SWIG_From_int((result));
21160 return resultobj;
21161 fail:
21162 return NULL;
21163 }
21164
21165
21166 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21167 PyObject *obj;
21168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21169 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21170 Py_INCREF(obj);
21171 return Py_BuildValue((char *)"");
21172 }
21173 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj;
21175 wxSysColourChangedEvent *result;
21176 char *kwnames[] = {
21177 NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21184
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21196 PyObject *obj;
21197 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21198 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21199 Py_INCREF(obj);
21200 return Py_BuildValue((char *)"");
21201 }
21202 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj;
21204 int arg1 = (int) 0 ;
21205 wxWindow *arg2 = (wxWindow *) NULL ;
21206 wxMouseCaptureChangedEvent *result;
21207 PyObject * obj0 = 0 ;
21208 PyObject * obj1 = 0 ;
21209 char *kwnames[] = {
21210 (char *) "winid",(char *) "gainedCapture", NULL
21211 };
21212
21213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21214 if (obj0) {
21215 {
21216 arg1 = (int)(SWIG_As_int(obj0));
21217 if (SWIG_arg_fail(1)) SWIG_fail;
21218 }
21219 }
21220 if (obj1) {
21221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21222 if (SWIG_arg_fail(2)) SWIG_fail;
21223 }
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21227
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj;
21240 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21241 wxWindow *result;
21242 PyObject * obj0 = 0 ;
21243 char *kwnames[] = {
21244 (char *) "self", NULL
21245 };
21246
21247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21249 if (SWIG_arg_fail(1)) SWIG_fail;
21250 {
21251 PyThreadState* __tstate = wxPyBeginAllowThreads();
21252 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21253
21254 wxPyEndAllowThreads(__tstate);
21255 if (PyErr_Occurred()) SWIG_fail;
21256 }
21257 {
21258 resultobj = wxPyMake_wxObject(result, 0);
21259 }
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21267 PyObject *obj;
21268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21269 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21270 Py_INCREF(obj);
21271 return Py_BuildValue((char *)"");
21272 }
21273 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21274 PyObject *resultobj;
21275 wxDisplayChangedEvent *result;
21276 char *kwnames[] = {
21277 NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21284
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21296 PyObject *obj;
21297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21298 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21299 Py_INCREF(obj);
21300 return Py_BuildValue((char *)"");
21301 }
21302 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21303 PyObject *resultobj;
21304 int arg1 = (int) 0 ;
21305 wxPaletteChangedEvent *result;
21306 PyObject * obj0 = 0 ;
21307 char *kwnames[] = {
21308 (char *) "id", NULL
21309 };
21310
21311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21312 if (obj0) {
21313 {
21314 arg1 = (int)(SWIG_As_int(obj0));
21315 if (SWIG_arg_fail(1)) SWIG_fail;
21316 }
21317 }
21318 {
21319 PyThreadState* __tstate = wxPyBeginAllowThreads();
21320 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21321
21322 wxPyEndAllowThreads(__tstate);
21323 if (PyErr_Occurred()) SWIG_fail;
21324 }
21325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj;
21334 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21335 wxWindow *arg2 = (wxWindow *) 0 ;
21336 PyObject * obj0 = 0 ;
21337 PyObject * obj1 = 0 ;
21338 char *kwnames[] = {
21339 (char *) "self",(char *) "win", NULL
21340 };
21341
21342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21344 if (SWIG_arg_fail(1)) SWIG_fail;
21345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21346 if (SWIG_arg_fail(2)) SWIG_fail;
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 (arg1)->SetChangedWindow(arg2);
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 Py_INCREF(Py_None); resultobj = Py_None;
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21364 wxWindow *result;
21365 PyObject * obj0 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "self", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (wxWindow *)(arg1)->GetChangedWindow();
21376
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = wxPyMake_wxObject(result, 0);
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21390 PyObject *obj;
21391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21392 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21393 Py_INCREF(obj);
21394 return Py_BuildValue((char *)"");
21395 }
21396 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21397 PyObject *resultobj;
21398 int arg1 = (int) 0 ;
21399 wxQueryNewPaletteEvent *result;
21400 PyObject * obj0 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "winid", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21406 if (obj0) {
21407 {
21408 arg1 = (int)(SWIG_As_int(obj0));
21409 if (SWIG_arg_fail(1)) SWIG_fail;
21410 }
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21415
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj;
21428 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21429 bool arg2 ;
21430 PyObject * obj0 = 0 ;
21431 PyObject * obj1 = 0 ;
21432 char *kwnames[] = {
21433 (char *) "self",(char *) "realized", NULL
21434 };
21435
21436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21438 if (SWIG_arg_fail(1)) SWIG_fail;
21439 {
21440 arg2 = (bool)(SWIG_As_bool(obj1));
21441 if (SWIG_arg_fail(2)) SWIG_fail;
21442 }
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 (arg1)->SetPaletteRealized(arg2);
21446
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 Py_INCREF(Py_None); resultobj = Py_None;
21451 return resultobj;
21452 fail:
21453 return NULL;
21454 }
21455
21456
21457 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21458 PyObject *resultobj;
21459 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21460 bool result;
21461 PyObject * obj0 = 0 ;
21462 char *kwnames[] = {
21463 (char *) "self", NULL
21464 };
21465
21466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21468 if (SWIG_arg_fail(1)) SWIG_fail;
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21472
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 {
21477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21478 }
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21486 PyObject *obj;
21487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21488 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21489 Py_INCREF(obj);
21490 return Py_BuildValue((char *)"");
21491 }
21492 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21493 PyObject *resultobj;
21494 wxNavigationKeyEvent *result;
21495 char *kwnames[] = {
21496 NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21503
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21515 PyObject *resultobj;
21516 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21517 bool result;
21518 PyObject * obj0 = 0 ;
21519 char *kwnames[] = {
21520 (char *) "self", NULL
21521 };
21522
21523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21525 if (SWIG_arg_fail(1)) SWIG_fail;
21526 {
21527 PyThreadState* __tstate = wxPyBeginAllowThreads();
21528 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21529
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 {
21534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21535 }
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21543 PyObject *resultobj;
21544 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21545 bool arg2 ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self",(char *) "forward", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 {
21556 arg2 = (bool)(SWIG_As_bool(obj1));
21557 if (SWIG_arg_fail(2)) SWIG_fail;
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 (arg1)->SetDirection(arg2);
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 Py_INCREF(Py_None); resultobj = Py_None;
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21574 PyObject *resultobj;
21575 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21576 bool result;
21577 PyObject * obj0 = 0 ;
21578 char *kwnames[] = {
21579 (char *) "self", NULL
21580 };
21581
21582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21584 if (SWIG_arg_fail(1)) SWIG_fail;
21585 {
21586 PyThreadState* __tstate = wxPyBeginAllowThreads();
21587 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21588
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 {
21593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21594 }
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21602 PyObject *resultobj;
21603 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21604 bool arg2 ;
21605 PyObject * obj0 = 0 ;
21606 PyObject * obj1 = 0 ;
21607 char *kwnames[] = {
21608 (char *) "self",(char *) "ischange", NULL
21609 };
21610
21611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21613 if (SWIG_arg_fail(1)) SWIG_fail;
21614 {
21615 arg2 = (bool)(SWIG_As_bool(obj1));
21616 if (SWIG_arg_fail(2)) SWIG_fail;
21617 }
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 (arg1)->SetWindowChange(arg2);
21621
21622 wxPyEndAllowThreads(__tstate);
21623 if (PyErr_Occurred()) SWIG_fail;
21624 }
21625 Py_INCREF(Py_None); resultobj = Py_None;
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21633 PyObject *resultobj;
21634 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21635 bool result;
21636 PyObject * obj0 = 0 ;
21637 char *kwnames[] = {
21638 (char *) "self", NULL
21639 };
21640
21641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21643 if (SWIG_arg_fail(1)) SWIG_fail;
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21647
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 {
21652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21653 }
21654 return resultobj;
21655 fail:
21656 return NULL;
21657 }
21658
21659
21660 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21661 PyObject *resultobj;
21662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21663 bool arg2 ;
21664 PyObject * obj0 = 0 ;
21665 PyObject * obj1 = 0 ;
21666 char *kwnames[] = {
21667 (char *) "self",(char *) "bIs", NULL
21668 };
21669
21670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21672 if (SWIG_arg_fail(1)) SWIG_fail;
21673 {
21674 arg2 = (bool)(SWIG_As_bool(obj1));
21675 if (SWIG_arg_fail(2)) SWIG_fail;
21676 }
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 (arg1)->SetFromTab(arg2);
21680
21681 wxPyEndAllowThreads(__tstate);
21682 if (PyErr_Occurred()) SWIG_fail;
21683 }
21684 Py_INCREF(Py_None); resultobj = Py_None;
21685 return resultobj;
21686 fail:
21687 return NULL;
21688 }
21689
21690
21691 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21692 PyObject *resultobj;
21693 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21694 long arg2 ;
21695 PyObject * obj0 = 0 ;
21696 PyObject * obj1 = 0 ;
21697 char *kwnames[] = {
21698 (char *) "self",(char *) "flags", NULL
21699 };
21700
21701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21703 if (SWIG_arg_fail(1)) SWIG_fail;
21704 {
21705 arg2 = (long)(SWIG_As_long(obj1));
21706 if (SWIG_arg_fail(2)) SWIG_fail;
21707 }
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 (arg1)->SetFlags(arg2);
21711
21712 wxPyEndAllowThreads(__tstate);
21713 if (PyErr_Occurred()) SWIG_fail;
21714 }
21715 Py_INCREF(Py_None); resultobj = Py_None;
21716 return resultobj;
21717 fail:
21718 return NULL;
21719 }
21720
21721
21722 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21723 PyObject *resultobj;
21724 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21725 wxWindow *result;
21726 PyObject * obj0 = 0 ;
21727 char *kwnames[] = {
21728 (char *) "self", NULL
21729 };
21730
21731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21733 if (SWIG_arg_fail(1)) SWIG_fail;
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21737
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 {
21742 resultobj = wxPyMake_wxObject(result, 0);
21743 }
21744 return resultobj;
21745 fail:
21746 return NULL;
21747 }
21748
21749
21750 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj;
21752 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21753 wxWindow *arg2 = (wxWindow *) 0 ;
21754 PyObject * obj0 = 0 ;
21755 PyObject * obj1 = 0 ;
21756 char *kwnames[] = {
21757 (char *) "self",(char *) "win", NULL
21758 };
21759
21760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21762 if (SWIG_arg_fail(1)) SWIG_fail;
21763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(2)) SWIG_fail;
21765 {
21766 PyThreadState* __tstate = wxPyBeginAllowThreads();
21767 (arg1)->SetCurrentFocus(arg2);
21768
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 Py_INCREF(Py_None); resultobj = Py_None;
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21780 PyObject *obj;
21781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21782 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21783 Py_INCREF(obj);
21784 return Py_BuildValue((char *)"");
21785 }
21786 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 wxWindow *arg1 = (wxWindow *) NULL ;
21789 wxWindowCreateEvent *result;
21790 PyObject * obj0 = 0 ;
21791 char *kwnames[] = {
21792 (char *) "win", NULL
21793 };
21794
21795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21796 if (obj0) {
21797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21798 if (SWIG_arg_fail(1)) SWIG_fail;
21799 }
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21803
21804 wxPyEndAllowThreads(__tstate);
21805 if (PyErr_Occurred()) SWIG_fail;
21806 }
21807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21815 PyObject *resultobj;
21816 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21817 wxWindow *result;
21818 PyObject * obj0 = 0 ;
21819 char *kwnames[] = {
21820 (char *) "self", NULL
21821 };
21822
21823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21825 if (SWIG_arg_fail(1)) SWIG_fail;
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21829
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 {
21834 resultobj = wxPyMake_wxObject(result, 0);
21835 }
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21843 PyObject *obj;
21844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21845 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21846 Py_INCREF(obj);
21847 return Py_BuildValue((char *)"");
21848 }
21849 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj;
21851 wxWindow *arg1 = (wxWindow *) NULL ;
21852 wxWindowDestroyEvent *result;
21853 PyObject * obj0 = 0 ;
21854 char *kwnames[] = {
21855 (char *) "win", NULL
21856 };
21857
21858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21859 if (obj0) {
21860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21861 if (SWIG_arg_fail(1)) SWIG_fail;
21862 }
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21866
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21880 wxWindow *result;
21881 PyObject * obj0 = 0 ;
21882 char *kwnames[] = {
21883 (char *) "self", NULL
21884 };
21885
21886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21888 if (SWIG_arg_fail(1)) SWIG_fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = wxPyMake_wxObject(result, 0);
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21906 PyObject *obj;
21907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21908 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21909 Py_INCREF(obj);
21910 return Py_BuildValue((char *)"");
21911 }
21912 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21913 PyObject *resultobj;
21914 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21915 int arg2 = (int) 0 ;
21916 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21917 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21918 wxContextMenuEvent *result;
21919 wxPoint temp3 ;
21920 PyObject * obj0 = 0 ;
21921 PyObject * obj1 = 0 ;
21922 PyObject * obj2 = 0 ;
21923 char *kwnames[] = {
21924 (char *) "type",(char *) "winid",(char *) "pt", NULL
21925 };
21926
21927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21928 if (obj0) {
21929 {
21930 arg1 = (wxEventType)(SWIG_As_int(obj0));
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 }
21933 }
21934 if (obj1) {
21935 {
21936 arg2 = (int)(SWIG_As_int(obj1));
21937 if (SWIG_arg_fail(2)) SWIG_fail;
21938 }
21939 }
21940 if (obj2) {
21941 {
21942 arg3 = &temp3;
21943 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21944 }
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21949
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21961 PyObject *resultobj;
21962 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21963 wxPoint *result;
21964 PyObject * obj0 = 0 ;
21965 char *kwnames[] = {
21966 (char *) "self", NULL
21967 };
21968
21969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21971 if (SWIG_arg_fail(1)) SWIG_fail;
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 {
21975 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21976 result = (wxPoint *) &_result_ref;
21977 }
21978
21979 wxPyEndAllowThreads(__tstate);
21980 if (PyErr_Occurred()) SWIG_fail;
21981 }
21982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21990 PyObject *resultobj;
21991 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21992 wxPoint *arg2 = 0 ;
21993 wxPoint temp2 ;
21994 PyObject * obj0 = 0 ;
21995 PyObject * obj1 = 0 ;
21996 char *kwnames[] = {
21997 (char *) "self",(char *) "pos", NULL
21998 };
21999
22000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 {
22004 arg2 = &temp2;
22005 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22006 }
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 (arg1)->SetPosition((wxPoint const &)*arg2);
22010
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 Py_INCREF(Py_None); resultobj = Py_None;
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22022 PyObject *obj;
22023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22024 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22025 Py_INCREF(obj);
22026 return Py_BuildValue((char *)"");
22027 }
22028 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj;
22030 wxIdleEvent *result;
22031 char *kwnames[] = {
22032 NULL
22033 };
22034
22035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 result = (wxIdleEvent *)new wxIdleEvent();
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj;
22052 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22053 bool arg2 = (bool) true ;
22054 PyObject * obj0 = 0 ;
22055 PyObject * obj1 = 0 ;
22056 char *kwnames[] = {
22057 (char *) "self",(char *) "needMore", NULL
22058 };
22059
22060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22062 if (SWIG_arg_fail(1)) SWIG_fail;
22063 if (obj1) {
22064 {
22065 arg2 = (bool)(SWIG_As_bool(obj1));
22066 if (SWIG_arg_fail(2)) SWIG_fail;
22067 }
22068 }
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 (arg1)->RequestMore(arg2);
22072
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 Py_INCREF(Py_None); resultobj = Py_None;
22077 return resultobj;
22078 fail:
22079 return NULL;
22080 }
22081
22082
22083 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj;
22085 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22086 bool result;
22087 PyObject * obj0 = 0 ;
22088 char *kwnames[] = {
22089 (char *) "self", NULL
22090 };
22091
22092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22094 if (SWIG_arg_fail(1)) SWIG_fail;
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22098
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 {
22103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22104 }
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxIdleMode arg1 ;
22114 PyObject * obj0 = 0 ;
22115 char *kwnames[] = {
22116 (char *) "mode", NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22120 {
22121 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22122 if (SWIG_arg_fail(1)) SWIG_fail;
22123 }
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 wxIdleEvent::SetMode((wxIdleMode )arg1);
22127
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 Py_INCREF(Py_None); resultobj = Py_None;
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxIdleMode result;
22141 char *kwnames[] = {
22142 NULL
22143 };
22144
22145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22146 {
22147 PyThreadState* __tstate = wxPyBeginAllowThreads();
22148 result = (wxIdleMode)wxIdleEvent::GetMode();
22149
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 resultobj = SWIG_From_int((result));
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22161 PyObject *resultobj;
22162 wxWindow *arg1 = (wxWindow *) 0 ;
22163 bool result;
22164 PyObject * obj0 = 0 ;
22165 char *kwnames[] = {
22166 (char *) "win", NULL
22167 };
22168
22169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22171 if (SWIG_arg_fail(1)) SWIG_fail;
22172 {
22173 PyThreadState* __tstate = wxPyBeginAllowThreads();
22174 result = (bool)wxIdleEvent::CanSend(arg1);
22175
22176 wxPyEndAllowThreads(__tstate);
22177 if (PyErr_Occurred()) SWIG_fail;
22178 }
22179 {
22180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22181 }
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22189 PyObject *obj;
22190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22191 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22192 Py_INCREF(obj);
22193 return Py_BuildValue((char *)"");
22194 }
22195 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 int arg1 = (int) 0 ;
22198 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22199 wxPyEvent *result;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char *kwnames[] = {
22203 (char *) "winid",(char *) "commandType", NULL
22204 };
22205
22206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22207 if (obj0) {
22208 {
22209 arg1 = (int)(SWIG_As_int(obj0));
22210 if (SWIG_arg_fail(1)) SWIG_fail;
22211 }
22212 }
22213 if (obj1) {
22214 {
22215 arg2 = (wxEventType)(SWIG_As_int(obj1));
22216 if (SWIG_arg_fail(2)) SWIG_fail;
22217 }
22218 }
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22222
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22234 PyObject *resultobj;
22235 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22236 PyObject * obj0 = 0 ;
22237 char *kwnames[] = {
22238 (char *) "self", NULL
22239 };
22240
22241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(1)) SWIG_fail;
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 delete arg1;
22247
22248 wxPyEndAllowThreads(__tstate);
22249 if (PyErr_Occurred()) SWIG_fail;
22250 }
22251 Py_INCREF(Py_None); resultobj = Py_None;
22252 return resultobj;
22253 fail:
22254 return NULL;
22255 }
22256
22257
22258 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22259 PyObject *resultobj;
22260 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22261 PyObject *arg2 = (PyObject *) 0 ;
22262 PyObject * obj0 = 0 ;
22263 PyObject * obj1 = 0 ;
22264 char *kwnames[] = {
22265 (char *) "self",(char *) "self", NULL
22266 };
22267
22268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22270 if (SWIG_arg_fail(1)) SWIG_fail;
22271 arg2 = obj1;
22272 {
22273 PyThreadState* __tstate = wxPyBeginAllowThreads();
22274 (arg1)->SetSelf(arg2);
22275
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 Py_INCREF(Py_None); resultobj = Py_None;
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22287 PyObject *resultobj;
22288 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22289 PyObject *result;
22290 PyObject * obj0 = 0 ;
22291 char *kwnames[] = {
22292 (char *) "self", NULL
22293 };
22294
22295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22297 if (SWIG_arg_fail(1)) SWIG_fail;
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (PyObject *)(arg1)->GetSelf();
22301
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 resultobj = result;
22306 return resultobj;
22307 fail:
22308 return NULL;
22309 }
22310
22311
22312 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22313 PyObject *obj;
22314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22315 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22316 Py_INCREF(obj);
22317 return Py_BuildValue((char *)"");
22318 }
22319 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22320 PyObject *resultobj;
22321 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22322 int arg2 = (int) 0 ;
22323 wxPyCommandEvent *result;
22324 PyObject * obj0 = 0 ;
22325 PyObject * obj1 = 0 ;
22326 char *kwnames[] = {
22327 (char *) "commandType",(char *) "id", NULL
22328 };
22329
22330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22331 if (obj0) {
22332 {
22333 arg1 = (wxEventType)(SWIG_As_int(obj0));
22334 if (SWIG_arg_fail(1)) SWIG_fail;
22335 }
22336 }
22337 if (obj1) {
22338 {
22339 arg2 = (int)(SWIG_As_int(obj1));
22340 if (SWIG_arg_fail(2)) SWIG_fail;
22341 }
22342 }
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22346
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22358 PyObject *resultobj;
22359 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22360 PyObject * obj0 = 0 ;
22361 char *kwnames[] = {
22362 (char *) "self", NULL
22363 };
22364
22365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22367 if (SWIG_arg_fail(1)) SWIG_fail;
22368 {
22369 PyThreadState* __tstate = wxPyBeginAllowThreads();
22370 delete arg1;
22371
22372 wxPyEndAllowThreads(__tstate);
22373 if (PyErr_Occurred()) SWIG_fail;
22374 }
22375 Py_INCREF(Py_None); resultobj = Py_None;
22376 return resultobj;
22377 fail:
22378 return NULL;
22379 }
22380
22381
22382 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22383 PyObject *resultobj;
22384 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22385 PyObject *arg2 = (PyObject *) 0 ;
22386 PyObject * obj0 = 0 ;
22387 PyObject * obj1 = 0 ;
22388 char *kwnames[] = {
22389 (char *) "self",(char *) "self", NULL
22390 };
22391
22392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22394 if (SWIG_arg_fail(1)) SWIG_fail;
22395 arg2 = obj1;
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 (arg1)->SetSelf(arg2);
22399
22400 wxPyEndAllowThreads(__tstate);
22401 if (PyErr_Occurred()) SWIG_fail;
22402 }
22403 Py_INCREF(Py_None); resultobj = Py_None;
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj;
22412 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22413 PyObject *result;
22414 PyObject * obj0 = 0 ;
22415 char *kwnames[] = {
22416 (char *) "self", NULL
22417 };
22418
22419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(1)) SWIG_fail;
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 result = (PyObject *)(arg1)->GetSelf();
22425
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = result;
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22437 PyObject *obj;
22438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22439 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22440 Py_INCREF(obj);
22441 return Py_BuildValue((char *)"");
22442 }
22443 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22444 PyObject *resultobj;
22445 wxWindow *arg1 = (wxWindow *) 0 ;
22446 wxDateTime *arg2 = 0 ;
22447 wxEventType arg3 ;
22448 wxDateEvent *result;
22449 PyObject * obj0 = 0 ;
22450 PyObject * obj1 = 0 ;
22451 PyObject * obj2 = 0 ;
22452 char *kwnames[] = {
22453 (char *) "win",(char *) "dt",(char *) "type", NULL
22454 };
22455
22456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22458 if (SWIG_arg_fail(1)) SWIG_fail;
22459 {
22460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(2)) SWIG_fail;
22462 if (arg2 == NULL) {
22463 SWIG_null_ref("wxDateTime");
22464 }
22465 if (SWIG_arg_fail(2)) SWIG_fail;
22466 }
22467 {
22468 arg3 = (wxEventType)(SWIG_As_int(obj2));
22469 if (SWIG_arg_fail(3)) SWIG_fail;
22470 }
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22474
22475 wxPyEndAllowThreads(__tstate);
22476 if (PyErr_Occurred()) SWIG_fail;
22477 }
22478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22486 PyObject *resultobj;
22487 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22488 wxDateTime *result;
22489 PyObject * obj0 = 0 ;
22490 char *kwnames[] = {
22491 (char *) "self", NULL
22492 };
22493
22494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22496 if (SWIG_arg_fail(1)) SWIG_fail;
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 {
22500 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22501 result = (wxDateTime *) &_result_ref;
22502 }
22503
22504 wxPyEndAllowThreads(__tstate);
22505 if (PyErr_Occurred()) SWIG_fail;
22506 }
22507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj;
22516 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22517 wxDateTime *arg2 = 0 ;
22518 PyObject * obj0 = 0 ;
22519 PyObject * obj1 = 0 ;
22520 char *kwnames[] = {
22521 (char *) "self",(char *) "date", NULL
22522 };
22523
22524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22526 if (SWIG_arg_fail(1)) SWIG_fail;
22527 {
22528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(2)) SWIG_fail;
22530 if (arg2 == NULL) {
22531 SWIG_null_ref("wxDateTime");
22532 }
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 (arg1)->SetDate((wxDateTime const &)*arg2);
22538
22539 wxPyEndAllowThreads(__tstate);
22540 if (PyErr_Occurred()) SWIG_fail;
22541 }
22542 Py_INCREF(Py_None); resultobj = Py_None;
22543 return resultobj;
22544 fail:
22545 return NULL;
22546 }
22547
22548
22549 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22550 PyObject *obj;
22551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22552 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22553 Py_INCREF(obj);
22554 return Py_BuildValue((char *)"");
22555 }
22556 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj;
22558 wxPyApp *result;
22559 char *kwnames[] = {
22560 NULL
22561 };
22562
22563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 result = (wxPyApp *)new_wxPyApp();
22567
22568 wxPyEndAllowThreads(__tstate);
22569 if (PyErr_Occurred()) SWIG_fail;
22570 }
22571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj;
22580 wxPyApp *arg1 = (wxPyApp *) 0 ;
22581 PyObject * obj0 = 0 ;
22582 char *kwnames[] = {
22583 (char *) "self", NULL
22584 };
22585
22586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22588 if (SWIG_arg_fail(1)) SWIG_fail;
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 delete arg1;
22592
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 Py_INCREF(Py_None); resultobj = Py_None;
22597 return resultobj;
22598 fail:
22599 return NULL;
22600 }
22601
22602
22603 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22604 PyObject *resultobj;
22605 wxPyApp *arg1 = (wxPyApp *) 0 ;
22606 PyObject *arg2 = (PyObject *) 0 ;
22607 PyObject *arg3 = (PyObject *) 0 ;
22608 PyObject * obj0 = 0 ;
22609 PyObject * obj1 = 0 ;
22610 PyObject * obj2 = 0 ;
22611 char *kwnames[] = {
22612 (char *) "self",(char *) "self",(char *) "_class", NULL
22613 };
22614
22615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22617 if (SWIG_arg_fail(1)) SWIG_fail;
22618 arg2 = obj1;
22619 arg3 = obj2;
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 (arg1)->_setCallbackInfo(arg2,arg3);
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 Py_INCREF(Py_None); resultobj = Py_None;
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj;
22636 wxPyApp *arg1 = (wxPyApp *) 0 ;
22637 wxString result;
22638 PyObject * obj0 = 0 ;
22639 char *kwnames[] = {
22640 (char *) "self", NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(1)) SWIG_fail;
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = ((wxPyApp const *)arg1)->GetAppName();
22649
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 {
22654 #if wxUSE_UNICODE
22655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22656 #else
22657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22658 #endif
22659 }
22660 return resultobj;
22661 fail:
22662 return NULL;
22663 }
22664
22665
22666 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22667 PyObject *resultobj;
22668 wxPyApp *arg1 = (wxPyApp *) 0 ;
22669 wxString *arg2 = 0 ;
22670 bool temp2 = false ;
22671 PyObject * obj0 = 0 ;
22672 PyObject * obj1 = 0 ;
22673 char *kwnames[] = {
22674 (char *) "self",(char *) "name", NULL
22675 };
22676
22677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22679 if (SWIG_arg_fail(1)) SWIG_fail;
22680 {
22681 arg2 = wxString_in_helper(obj1);
22682 if (arg2 == NULL) SWIG_fail;
22683 temp2 = true;
22684 }
22685 {
22686 PyThreadState* __tstate = wxPyBeginAllowThreads();
22687 (arg1)->SetAppName((wxString const &)*arg2);
22688
22689 wxPyEndAllowThreads(__tstate);
22690 if (PyErr_Occurred()) SWIG_fail;
22691 }
22692 Py_INCREF(Py_None); resultobj = Py_None;
22693 {
22694 if (temp2)
22695 delete arg2;
22696 }
22697 return resultobj;
22698 fail:
22699 {
22700 if (temp2)
22701 delete arg2;
22702 }
22703 return NULL;
22704 }
22705
22706
22707 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22708 PyObject *resultobj;
22709 wxPyApp *arg1 = (wxPyApp *) 0 ;
22710 wxString result;
22711 PyObject * obj0 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 result = ((wxPyApp const *)arg1)->GetClassName();
22722
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 #if wxUSE_UNICODE
22728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22729 #else
22730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22731 #endif
22732 }
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 wxString *arg2 = 0 ;
22743 bool temp2 = false ;
22744 PyObject * obj0 = 0 ;
22745 PyObject * obj1 = 0 ;
22746 char *kwnames[] = {
22747 (char *) "self",(char *) "name", NULL
22748 };
22749
22750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22752 if (SWIG_arg_fail(1)) SWIG_fail;
22753 {
22754 arg2 = wxString_in_helper(obj1);
22755 if (arg2 == NULL) SWIG_fail;
22756 temp2 = true;
22757 }
22758 {
22759 PyThreadState* __tstate = wxPyBeginAllowThreads();
22760 (arg1)->SetClassName((wxString const &)*arg2);
22761
22762 wxPyEndAllowThreads(__tstate);
22763 if (PyErr_Occurred()) SWIG_fail;
22764 }
22765 Py_INCREF(Py_None); resultobj = Py_None;
22766 {
22767 if (temp2)
22768 delete arg2;
22769 }
22770 return resultobj;
22771 fail:
22772 {
22773 if (temp2)
22774 delete arg2;
22775 }
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj;
22782 wxPyApp *arg1 = (wxPyApp *) 0 ;
22783 wxString *result;
22784 PyObject * obj0 = 0 ;
22785 char *kwnames[] = {
22786 (char *) "self", NULL
22787 };
22788
22789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(1)) SWIG_fail;
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 {
22795 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22796 result = (wxString *) &_result_ref;
22797 }
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 {
22803 #if wxUSE_UNICODE
22804 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22805 #else
22806 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22807 #endif
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22816 PyObject *resultobj;
22817 wxPyApp *arg1 = (wxPyApp *) 0 ;
22818 wxString *arg2 = 0 ;
22819 bool temp2 = false ;
22820 PyObject * obj0 = 0 ;
22821 PyObject * obj1 = 0 ;
22822 char *kwnames[] = {
22823 (char *) "self",(char *) "name", NULL
22824 };
22825
22826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22828 if (SWIG_arg_fail(1)) SWIG_fail;
22829 {
22830 arg2 = wxString_in_helper(obj1);
22831 if (arg2 == NULL) SWIG_fail;
22832 temp2 = true;
22833 }
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 (arg1)->SetVendorName((wxString const &)*arg2);
22837
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 Py_INCREF(Py_None); resultobj = Py_None;
22842 {
22843 if (temp2)
22844 delete arg2;
22845 }
22846 return resultobj;
22847 fail:
22848 {
22849 if (temp2)
22850 delete arg2;
22851 }
22852 return NULL;
22853 }
22854
22855
22856 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22857 PyObject *resultobj;
22858 wxPyApp *arg1 = (wxPyApp *) 0 ;
22859 wxAppTraits *result;
22860 PyObject * obj0 = 0 ;
22861 char *kwnames[] = {
22862 (char *) "self", NULL
22863 };
22864
22865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22867 if (SWIG_arg_fail(1)) SWIG_fail;
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 result = (wxAppTraits *)(arg1)->GetTraits();
22871
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22883 PyObject *resultobj;
22884 wxPyApp *arg1 = (wxPyApp *) 0 ;
22885 PyObject * obj0 = 0 ;
22886 char *kwnames[] = {
22887 (char *) "self", NULL
22888 };
22889
22890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22892 if (SWIG_arg_fail(1)) SWIG_fail;
22893 {
22894 PyThreadState* __tstate = wxPyBeginAllowThreads();
22895 (arg1)->ProcessPendingEvents();
22896
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 Py_INCREF(Py_None); resultobj = Py_None;
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22908 PyObject *resultobj;
22909 wxPyApp *arg1 = (wxPyApp *) 0 ;
22910 bool arg2 = (bool) false ;
22911 bool result;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914 char *kwnames[] = {
22915 (char *) "self",(char *) "onlyIfNeeded", NULL
22916 };
22917
22918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22920 if (SWIG_arg_fail(1)) SWIG_fail;
22921 if (obj1) {
22922 {
22923 arg2 = (bool)(SWIG_As_bool(obj1));
22924 if (SWIG_arg_fail(2)) SWIG_fail;
22925 }
22926 }
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 result = (bool)(arg1)->Yield(arg2);
22930
22931 wxPyEndAllowThreads(__tstate);
22932 if (PyErr_Occurred()) SWIG_fail;
22933 }
22934 {
22935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22936 }
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22944 PyObject *resultobj;
22945 wxPyApp *arg1 = (wxPyApp *) 0 ;
22946 PyObject * obj0 = 0 ;
22947 char *kwnames[] = {
22948 (char *) "self", NULL
22949 };
22950
22951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22953 if (SWIG_arg_fail(1)) SWIG_fail;
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 (arg1)->WakeUpIdle();
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 Py_INCREF(Py_None); resultobj = Py_None;
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj;
22970 bool result;
22971 char *kwnames[] = {
22972 NULL
22973 };
22974
22975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (bool)wxPyApp::IsMainLoopRunning();
22979
22980 wxPyEndAllowThreads(__tstate);
22981 if (PyErr_Occurred()) SWIG_fail;
22982 }
22983 {
22984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22985 }
22986 return resultobj;
22987 fail:
22988 return NULL;
22989 }
22990
22991
22992 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22993 PyObject *resultobj;
22994 wxPyApp *arg1 = (wxPyApp *) 0 ;
22995 int result;
22996 PyObject * obj0 = 0 ;
22997 char *kwnames[] = {
22998 (char *) "self", NULL
22999 };
23000
23001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23003 if (SWIG_arg_fail(1)) SWIG_fail;
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (int)(arg1)->MainLoop();
23007
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 {
23012 resultobj = SWIG_From_int((int)(result));
23013 }
23014 return resultobj;
23015 fail:
23016 return NULL;
23017 }
23018
23019
23020 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23021 PyObject *resultobj;
23022 wxPyApp *arg1 = (wxPyApp *) 0 ;
23023 PyObject * obj0 = 0 ;
23024 char *kwnames[] = {
23025 (char *) "self", NULL
23026 };
23027
23028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23030 if (SWIG_arg_fail(1)) SWIG_fail;
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 (arg1)->Exit();
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 Py_INCREF(Py_None); resultobj = Py_None;
23039 return resultobj;
23040 fail:
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj;
23047 wxPyApp *arg1 = (wxPyApp *) 0 ;
23048 PyObject * obj0 = 0 ;
23049 char *kwnames[] = {
23050 (char *) "self", NULL
23051 };
23052
23053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23055 if (SWIG_arg_fail(1)) SWIG_fail;
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 (arg1)->ExitMainLoop();
23059
23060 wxPyEndAllowThreads(__tstate);
23061 if (PyErr_Occurred()) SWIG_fail;
23062 }
23063 Py_INCREF(Py_None); resultobj = Py_None;
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj;
23072 wxPyApp *arg1 = (wxPyApp *) 0 ;
23073 bool result;
23074 PyObject * obj0 = 0 ;
23075 char *kwnames[] = {
23076 (char *) "self", NULL
23077 };
23078
23079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23081 if (SWIG_arg_fail(1)) SWIG_fail;
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)(arg1)->Pending();
23085
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 {
23090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj;
23100 wxPyApp *arg1 = (wxPyApp *) 0 ;
23101 bool result;
23102 PyObject * obj0 = 0 ;
23103 char *kwnames[] = {
23104 (char *) "self", NULL
23105 };
23106
23107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23109 if (SWIG_arg_fail(1)) SWIG_fail;
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (bool)(arg1)->Dispatch();
23113
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 {
23118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23119 }
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23127 PyObject *resultobj;
23128 wxPyApp *arg1 = (wxPyApp *) 0 ;
23129 bool result;
23130 PyObject * obj0 = 0 ;
23131 char *kwnames[] = {
23132 (char *) "self", NULL
23133 };
23134
23135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23137 if (SWIG_arg_fail(1)) SWIG_fail;
23138 {
23139 PyThreadState* __tstate = wxPyBeginAllowThreads();
23140 result = (bool)(arg1)->ProcessIdle();
23141
23142 wxPyEndAllowThreads(__tstate);
23143 if (PyErr_Occurred()) SWIG_fail;
23144 }
23145 {
23146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23147 }
23148 return resultobj;
23149 fail:
23150 return NULL;
23151 }
23152
23153
23154 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23155 PyObject *resultobj;
23156 wxPyApp *arg1 = (wxPyApp *) 0 ;
23157 wxWindow *arg2 = (wxWindow *) 0 ;
23158 wxIdleEvent *arg3 = 0 ;
23159 bool result;
23160 PyObject * obj0 = 0 ;
23161 PyObject * obj1 = 0 ;
23162 PyObject * obj2 = 0 ;
23163 char *kwnames[] = {
23164 (char *) "self",(char *) "win",(char *) "event", NULL
23165 };
23166
23167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23169 if (SWIG_arg_fail(1)) SWIG_fail;
23170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(2)) SWIG_fail;
23172 {
23173 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23174 if (SWIG_arg_fail(3)) SWIG_fail;
23175 if (arg3 == NULL) {
23176 SWIG_null_ref("wxIdleEvent");
23177 }
23178 if (SWIG_arg_fail(3)) SWIG_fail;
23179 }
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj;
23198 wxPyApp *arg1 = (wxPyApp *) 0 ;
23199 bool result;
23200 PyObject * obj0 = 0 ;
23201 char *kwnames[] = {
23202 (char *) "self", NULL
23203 };
23204
23205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23207 if (SWIG_arg_fail(1)) SWIG_fail;
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (bool)((wxPyApp const *)arg1)->IsActive();
23211
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 {
23216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23217 }
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23225 PyObject *resultobj;
23226 wxPyApp *arg1 = (wxPyApp *) 0 ;
23227 wxWindow *arg2 = (wxWindow *) 0 ;
23228 PyObject * obj0 = 0 ;
23229 PyObject * obj1 = 0 ;
23230 char *kwnames[] = {
23231 (char *) "self",(char *) "win", NULL
23232 };
23233
23234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23236 if (SWIG_arg_fail(1)) SWIG_fail;
23237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23238 if (SWIG_arg_fail(2)) SWIG_fail;
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 (arg1)->SetTopWindow(arg2);
23242
23243 wxPyEndAllowThreads(__tstate);
23244 if (PyErr_Occurred()) SWIG_fail;
23245 }
23246 Py_INCREF(Py_None); resultobj = Py_None;
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23254 PyObject *resultobj;
23255 wxPyApp *arg1 = (wxPyApp *) 0 ;
23256 wxWindow *result;
23257 PyObject * obj0 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23268
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 {
23273 resultobj = wxPyMake_wxObject(result, 0);
23274 }
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23282 PyObject *resultobj;
23283 wxPyApp *arg1 = (wxPyApp *) 0 ;
23284 bool arg2 ;
23285 PyObject * obj0 = 0 ;
23286 PyObject * obj1 = 0 ;
23287 char *kwnames[] = {
23288 (char *) "self",(char *) "flag", NULL
23289 };
23290
23291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23293 if (SWIG_arg_fail(1)) SWIG_fail;
23294 {
23295 arg2 = (bool)(SWIG_As_bool(obj1));
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 (arg1)->SetExitOnFrameDelete(arg2);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 wxPyApp *arg1 = (wxPyApp *) 0 ;
23315 bool result;
23316 PyObject * obj0 = 0 ;
23317 char *kwnames[] = {
23318 (char *) "self", NULL
23319 };
23320
23321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23327
23328 wxPyEndAllowThreads(__tstate);
23329 if (PyErr_Occurred()) SWIG_fail;
23330 }
23331 {
23332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23333 }
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj;
23342 wxPyApp *arg1 = (wxPyApp *) 0 ;
23343 bool arg2 ;
23344 PyObject * obj0 = 0 ;
23345 PyObject * obj1 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self",(char *) "flag", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(1)) SWIG_fail;
23353 {
23354 arg2 = (bool)(SWIG_As_bool(obj1));
23355 if (SWIG_arg_fail(2)) SWIG_fail;
23356 }
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 (arg1)->SetUseBestVisual(arg2);
23360
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 Py_INCREF(Py_None); resultobj = Py_None;
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxPyApp *arg1 = (wxPyApp *) 0 ;
23374 bool result;
23375 PyObject * obj0 = 0 ;
23376 char *kwnames[] = {
23377 (char *) "self", NULL
23378 };
23379
23380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23382 if (SWIG_arg_fail(1)) SWIG_fail;
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23386
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 {
23391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23392 }
23393 return resultobj;
23394 fail:
23395 return NULL;
23396 }
23397
23398
23399 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23400 PyObject *resultobj;
23401 wxPyApp *arg1 = (wxPyApp *) 0 ;
23402 int arg2 ;
23403 PyObject * obj0 = 0 ;
23404 PyObject * obj1 = 0 ;
23405 char *kwnames[] = {
23406 (char *) "self",(char *) "mode", NULL
23407 };
23408
23409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23411 if (SWIG_arg_fail(1)) SWIG_fail;
23412 {
23413 arg2 = (int)(SWIG_As_int(obj1));
23414 if (SWIG_arg_fail(2)) SWIG_fail;
23415 }
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 (arg1)->SetPrintMode(arg2);
23419
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 Py_INCREF(Py_None); resultobj = Py_None;
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxPyApp *arg1 = (wxPyApp *) 0 ;
23433 int result;
23434 PyObject * obj0 = 0 ;
23435 char *kwnames[] = {
23436 (char *) "self", NULL
23437 };
23438
23439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23441 if (SWIG_arg_fail(1)) SWIG_fail;
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23445
23446 wxPyEndAllowThreads(__tstate);
23447 if (PyErr_Occurred()) SWIG_fail;
23448 }
23449 {
23450 resultobj = SWIG_From_int((int)(result));
23451 }
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj;
23460 wxPyApp *arg1 = (wxPyApp *) 0 ;
23461 int arg2 ;
23462 PyObject * obj0 = 0 ;
23463 PyObject * obj1 = 0 ;
23464 char *kwnames[] = {
23465 (char *) "self",(char *) "mode", NULL
23466 };
23467
23468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23470 if (SWIG_arg_fail(1)) SWIG_fail;
23471 {
23472 arg2 = (int)(SWIG_As_int(obj1));
23473 if (SWIG_arg_fail(2)) SWIG_fail;
23474 }
23475 {
23476 PyThreadState* __tstate = wxPyBeginAllowThreads();
23477 (arg1)->SetAssertMode(arg2);
23478
23479 wxPyEndAllowThreads(__tstate);
23480 if (PyErr_Occurred()) SWIG_fail;
23481 }
23482 Py_INCREF(Py_None); resultobj = Py_None;
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23490 PyObject *resultobj;
23491 wxPyApp *arg1 = (wxPyApp *) 0 ;
23492 int result;
23493 PyObject * obj0 = 0 ;
23494 char *kwnames[] = {
23495 (char *) "self", NULL
23496 };
23497
23498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(1)) SWIG_fail;
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = (int)(arg1)->GetAssertMode();
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 resultobj = SWIG_From_int((int)(result));
23510 }
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23518 PyObject *resultobj;
23519 bool result;
23520 char *kwnames[] = {
23521 NULL
23522 };
23523
23524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23528
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj;
23543 long result;
23544 char *kwnames[] = {
23545 NULL
23546 };
23547
23548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23549 {
23550 PyThreadState* __tstate = wxPyBeginAllowThreads();
23551 result = (long)wxPyApp::GetMacAboutMenuItemId();
23552
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 {
23557 resultobj = SWIG_From_long((long)(result));
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj;
23567 long result;
23568 char *kwnames[] = {
23569 NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23576
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 {
23581 resultobj = SWIG_From_long((long)(result));
23582 }
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj;
23591 long result;
23592 char *kwnames[] = {
23593 NULL
23594 };
23595
23596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 result = (long)wxPyApp::GetMacExitMenuItemId();
23600
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 {
23605 resultobj = SWIG_From_long((long)(result));
23606 }
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj;
23615 wxString result;
23616 char *kwnames[] = {
23617 NULL
23618 };
23619
23620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = wxPyApp::GetMacHelpMenuTitleName();
23624
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 #if wxUSE_UNICODE
23630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23631 #else
23632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23633 #endif
23634 }
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj;
23643 bool arg1 ;
23644 PyObject * obj0 = 0 ;
23645 char *kwnames[] = {
23646 (char *) "val", NULL
23647 };
23648
23649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23650 {
23651 arg1 = (bool)(SWIG_As_bool(obj0));
23652 if (SWIG_arg_fail(1)) SWIG_fail;
23653 }
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23657
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 Py_INCREF(Py_None); resultobj = Py_None;
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj;
23670 long arg1 ;
23671 PyObject * obj0 = 0 ;
23672 char *kwnames[] = {
23673 (char *) "val", NULL
23674 };
23675
23676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23677 {
23678 arg1 = (long)(SWIG_As_long(obj0));
23679 if (SWIG_arg_fail(1)) SWIG_fail;
23680 }
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 wxPyApp::SetMacAboutMenuItemId(arg1);
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 Py_INCREF(Py_None); resultobj = Py_None;
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 long arg1 ;
23698 PyObject * obj0 = 0 ;
23699 char *kwnames[] = {
23700 (char *) "val", NULL
23701 };
23702
23703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23704 {
23705 arg1 = (long)(SWIG_As_long(obj0));
23706 if (SWIG_arg_fail(1)) SWIG_fail;
23707 }
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23711
23712 wxPyEndAllowThreads(__tstate);
23713 if (PyErr_Occurred()) SWIG_fail;
23714 }
23715 Py_INCREF(Py_None); resultobj = Py_None;
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 long arg1 ;
23725 PyObject * obj0 = 0 ;
23726 char *kwnames[] = {
23727 (char *) "val", NULL
23728 };
23729
23730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23731 {
23732 arg1 = (long)(SWIG_As_long(obj0));
23733 if (SWIG_arg_fail(1)) SWIG_fail;
23734 }
23735 {
23736 PyThreadState* __tstate = wxPyBeginAllowThreads();
23737 wxPyApp::SetMacExitMenuItemId(arg1);
23738
23739 wxPyEndAllowThreads(__tstate);
23740 if (PyErr_Occurred()) SWIG_fail;
23741 }
23742 Py_INCREF(Py_None); resultobj = Py_None;
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23750 PyObject *resultobj;
23751 wxString *arg1 = 0 ;
23752 bool temp1 = false ;
23753 PyObject * obj0 = 0 ;
23754 char *kwnames[] = {
23755 (char *) "val", NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23759 {
23760 arg1 = wxString_in_helper(obj0);
23761 if (arg1 == NULL) SWIG_fail;
23762 temp1 = true;
23763 }
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 Py_INCREF(Py_None); resultobj = Py_None;
23772 {
23773 if (temp1)
23774 delete arg1;
23775 }
23776 return resultobj;
23777 fail:
23778 {
23779 if (temp1)
23780 delete arg1;
23781 }
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 wxPyApp *arg1 = (wxPyApp *) 0 ;
23789 PyObject * obj0 = 0 ;
23790 char *kwnames[] = {
23791 (char *) "self", NULL
23792 };
23793
23794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 (arg1)->_BootstrapApp();
23800
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 Py_INCREF(Py_None); resultobj = Py_None;
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj;
23813 int result;
23814 char *kwnames[] = {
23815 NULL
23816 };
23817
23818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23819 {
23820 PyThreadState* __tstate = wxPyBeginAllowThreads();
23821 result = (int)PyApp_GetComCtl32Version();
23822
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 {
23827 resultobj = SWIG_From_int((int)(result));
23828 }
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23836 PyObject *obj;
23837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23838 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23839 Py_INCREF(obj);
23840 return Py_BuildValue((char *)"");
23841 }
23842 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23843 PyObject *resultobj;
23844 char *kwnames[] = {
23845 NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23849 {
23850 PyThreadState* __tstate = wxPyBeginAllowThreads();
23851 wxExit();
23852
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 Py_INCREF(Py_None); resultobj = Py_None;
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj;
23865 bool result;
23866 char *kwnames[] = {
23867 NULL
23868 };
23869
23870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = (bool)wxYield();
23874
23875 wxPyEndAllowThreads(__tstate);
23876 if (PyErr_Occurred()) SWIG_fail;
23877 }
23878 {
23879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23880 }
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 bool result;
23890 char *kwnames[] = {
23891 NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (bool)wxYieldIfNeeded();
23898
23899 wxPyEndAllowThreads(__tstate);
23900 if (PyErr_Occurred()) SWIG_fail;
23901 }
23902 {
23903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23904 }
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23912 PyObject *resultobj;
23913 wxWindow *arg1 = (wxWindow *) NULL ;
23914 bool arg2 = (bool) false ;
23915 bool result;
23916 PyObject * obj0 = 0 ;
23917 PyObject * obj1 = 0 ;
23918 char *kwnames[] = {
23919 (char *) "win",(char *) "onlyIfNeeded", NULL
23920 };
23921
23922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23923 if (obj0) {
23924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23925 if (SWIG_arg_fail(1)) SWIG_fail;
23926 }
23927 if (obj1) {
23928 {
23929 arg2 = (bool)(SWIG_As_bool(obj1));
23930 if (SWIG_arg_fail(2)) SWIG_fail;
23931 }
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (bool)wxSafeYield(arg1,arg2);
23936
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 {
23941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23942 }
23943 return resultobj;
23944 fail:
23945 return NULL;
23946 }
23947
23948
23949 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj;
23951 char *kwnames[] = {
23952 NULL
23953 };
23954
23955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 wxWakeUpIdle();
23959
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 Py_INCREF(Py_None); resultobj = Py_None;
23964 return resultobj;
23965 fail:
23966 return NULL;
23967 }
23968
23969
23970 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23971 PyObject *resultobj;
23972 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23973 wxEvent *arg2 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char *kwnames[] = {
23977 (char *) "dest",(char *) "event", NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23982 if (SWIG_arg_fail(1)) SWIG_fail;
23983 {
23984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23985 if (SWIG_arg_fail(2)) SWIG_fail;
23986 if (arg2 == NULL) {
23987 SWIG_null_ref("wxEvent");
23988 }
23989 if (SWIG_arg_fail(2)) SWIG_fail;
23990 }
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 wxPostEvent(arg1,*arg2);
23994
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 Py_INCREF(Py_None); resultobj = Py_None;
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24006 PyObject *resultobj;
24007 char *kwnames[] = {
24008 NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 wxApp_CleanUp();
24015
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 Py_INCREF(Py_None); resultobj = Py_None;
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 wxPyApp *result;
24029 char *kwnames[] = {
24030 NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (wxPyApp *)wxPyGetApp();
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 {
24042 resultobj = wxPyMake_wxObject(result, 0);
24043 }
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24051 PyObject *resultobj;
24052 char *arg1 = (char *) 0 ;
24053 PyObject * obj0 = 0 ;
24054 char *kwnames[] = {
24055 (char *) "encoding", NULL
24056 };
24057
24058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24059 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24060 SWIG_arg_fail(1);SWIG_fail;
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 wxSetDefaultPyEncoding((char const *)arg1);
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 Py_INCREF(Py_None); resultobj = Py_None;
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj;
24078 char *result;
24079 char *kwnames[] = {
24080 NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = (char *)wxGetDefaultPyEncoding();
24087
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 resultobj = SWIG_FromCharPtr(result);
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24099 PyObject *resultobj;
24100 wxEventLoop *result;
24101 char *kwnames[] = {
24102 NULL
24103 };
24104
24105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (wxEventLoop *)new wxEventLoop();
24109
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj;
24122 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24123 PyObject * obj0 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 delete arg1;
24134
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 Py_INCREF(Py_None); resultobj = Py_None;
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj;
24147 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24148 int result;
24149 PyObject * obj0 = 0 ;
24150 char *kwnames[] = {
24151 (char *) "self", NULL
24152 };
24153
24154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24156 if (SWIG_arg_fail(1)) SWIG_fail;
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (int)(arg1)->Run();
24160
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = SWIG_From_int((int)(result));
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24174 PyObject *resultobj;
24175 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24176 int arg2 = (int) 0 ;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 char *kwnames[] = {
24180 (char *) "self",(char *) "rc", NULL
24181 };
24182
24183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24185 if (SWIG_arg_fail(1)) SWIG_fail;
24186 if (obj1) {
24187 {
24188 arg2 = (int)(SWIG_As_int(obj1));
24189 if (SWIG_arg_fail(2)) SWIG_fail;
24190 }
24191 }
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 (arg1)->Exit(arg2);
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 Py_INCREF(Py_None); resultobj = Py_None;
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24207 PyObject *resultobj;
24208 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24209 bool result;
24210 PyObject * obj0 = 0 ;
24211 char *kwnames[] = {
24212 (char *) "self", NULL
24213 };
24214
24215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24217 if (SWIG_arg_fail(1)) SWIG_fail;
24218 {
24219 PyThreadState* __tstate = wxPyBeginAllowThreads();
24220 result = (bool)((wxEventLoop const *)arg1)->Pending();
24221
24222 wxPyEndAllowThreads(__tstate);
24223 if (PyErr_Occurred()) SWIG_fail;
24224 }
24225 {
24226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24227 }
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24235 PyObject *resultobj;
24236 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24237 bool result;
24238 PyObject * obj0 = 0 ;
24239 char *kwnames[] = {
24240 (char *) "self", NULL
24241 };
24242
24243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24245 if (SWIG_arg_fail(1)) SWIG_fail;
24246 {
24247 PyThreadState* __tstate = wxPyBeginAllowThreads();
24248 result = (bool)(arg1)->Dispatch();
24249
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 {
24254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24255 }
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24263 PyObject *resultobj;
24264 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24265 bool result;
24266 PyObject * obj0 = 0 ;
24267 char *kwnames[] = {
24268 (char *) "self", NULL
24269 };
24270
24271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24273 if (SWIG_arg_fail(1)) SWIG_fail;
24274 {
24275 PyThreadState* __tstate = wxPyBeginAllowThreads();
24276 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24277
24278 wxPyEndAllowThreads(__tstate);
24279 if (PyErr_Occurred()) SWIG_fail;
24280 }
24281 {
24282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24283 }
24284 return resultobj;
24285 fail:
24286 return NULL;
24287 }
24288
24289
24290 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24291 PyObject *resultobj;
24292 wxEventLoop *result;
24293 char *kwnames[] = {
24294 NULL
24295 };
24296
24297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 result = (wxEventLoop *)wxEventLoop::GetActive();
24301
24302 wxPyEndAllowThreads(__tstate);
24303 if (PyErr_Occurred()) SWIG_fail;
24304 }
24305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj;
24314 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24315 PyObject * obj0 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "loop", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 wxEventLoop::SetActive(arg1);
24326
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 Py_INCREF(Py_None); resultobj = Py_None;
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24338 PyObject *obj;
24339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24340 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24341 Py_INCREF(obj);
24342 return Py_BuildValue((char *)"");
24343 }
24344 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24345 PyObject *resultobj;
24346 int arg1 = (int) 0 ;
24347 int arg2 = (int) 0 ;
24348 int arg3 = (int) 0 ;
24349 wxAcceleratorEntry *result;
24350 PyObject * obj0 = 0 ;
24351 PyObject * obj1 = 0 ;
24352 PyObject * obj2 = 0 ;
24353 char *kwnames[] = {
24354 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24358 if (obj0) {
24359 {
24360 arg1 = (int)(SWIG_As_int(obj0));
24361 if (SWIG_arg_fail(1)) SWIG_fail;
24362 }
24363 }
24364 if (obj1) {
24365 {
24366 arg2 = (int)(SWIG_As_int(obj1));
24367 if (SWIG_arg_fail(2)) SWIG_fail;
24368 }
24369 }
24370 if (obj2) {
24371 {
24372 arg3 = (int)(SWIG_As_int(obj2));
24373 if (SWIG_arg_fail(3)) SWIG_fail;
24374 }
24375 }
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24379
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24391 PyObject *resultobj;
24392 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24393 PyObject * obj0 = 0 ;
24394 char *kwnames[] = {
24395 (char *) "self", NULL
24396 };
24397
24398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 delete arg1;
24404
24405 wxPyEndAllowThreads(__tstate);
24406 if (PyErr_Occurred()) SWIG_fail;
24407 }
24408 Py_INCREF(Py_None); resultobj = Py_None;
24409 return resultobj;
24410 fail:
24411 return NULL;
24412 }
24413
24414
24415 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj;
24417 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24418 int arg2 ;
24419 int arg3 ;
24420 int arg4 ;
24421 PyObject * obj0 = 0 ;
24422 PyObject * obj1 = 0 ;
24423 PyObject * obj2 = 0 ;
24424 PyObject * obj3 = 0 ;
24425 char *kwnames[] = {
24426 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24427 };
24428
24429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24431 if (SWIG_arg_fail(1)) SWIG_fail;
24432 {
24433 arg2 = (int)(SWIG_As_int(obj1));
24434 if (SWIG_arg_fail(2)) SWIG_fail;
24435 }
24436 {
24437 arg3 = (int)(SWIG_As_int(obj2));
24438 if (SWIG_arg_fail(3)) SWIG_fail;
24439 }
24440 {
24441 arg4 = (int)(SWIG_As_int(obj3));
24442 if (SWIG_arg_fail(4)) SWIG_fail;
24443 }
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 (arg1)->Set(arg2,arg3,arg4);
24447
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 Py_INCREF(Py_None); resultobj = Py_None;
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24459 PyObject *resultobj;
24460 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24461 int result;
24462 PyObject * obj0 = 0 ;
24463 char *kwnames[] = {
24464 (char *) "self", NULL
24465 };
24466
24467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24469 if (SWIG_arg_fail(1)) SWIG_fail;
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (int)(arg1)->GetFlags();
24473
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 {
24478 resultobj = SWIG_From_int((int)(result));
24479 }
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj;
24488 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24489 int result;
24490 PyObject * obj0 = 0 ;
24491 char *kwnames[] = {
24492 (char *) "self", NULL
24493 };
24494
24495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24497 if (SWIG_arg_fail(1)) SWIG_fail;
24498 {
24499 PyThreadState* __tstate = wxPyBeginAllowThreads();
24500 result = (int)(arg1)->GetKeyCode();
24501
24502 wxPyEndAllowThreads(__tstate);
24503 if (PyErr_Occurred()) SWIG_fail;
24504 }
24505 {
24506 resultobj = SWIG_From_int((int)(result));
24507 }
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24515 PyObject *resultobj;
24516 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24517 int result;
24518 PyObject * obj0 = 0 ;
24519 char *kwnames[] = {
24520 (char *) "self", NULL
24521 };
24522
24523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24525 if (SWIG_arg_fail(1)) SWIG_fail;
24526 {
24527 PyThreadState* __tstate = wxPyBeginAllowThreads();
24528 result = (int)(arg1)->GetCommand();
24529
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 {
24534 resultobj = SWIG_From_int((int)(result));
24535 }
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24543 PyObject *obj;
24544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24545 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24546 Py_INCREF(obj);
24547 return Py_BuildValue((char *)"");
24548 }
24549 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj;
24551 int arg1 ;
24552 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24553 wxAcceleratorTable *result;
24554 PyObject * obj0 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "n", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24560 {
24561 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24562 if (arg2) arg1 = PyList_Size(obj0);
24563 else arg1 = 0;
24564 }
24565 {
24566 PyThreadState* __tstate = wxPyBeginAllowThreads();
24567 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24568
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24573 {
24574 delete [] arg2;
24575 }
24576 return resultobj;
24577 fail:
24578 {
24579 delete [] arg2;
24580 }
24581 return NULL;
24582 }
24583
24584
24585 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24586 PyObject *resultobj;
24587 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24588 PyObject * obj0 = 0 ;
24589 char *kwnames[] = {
24590 (char *) "self", NULL
24591 };
24592
24593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24595 if (SWIG_arg_fail(1)) SWIG_fail;
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 delete arg1;
24599
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 Py_INCREF(Py_None); resultobj = Py_None;
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj;
24612 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24613 bool result;
24614 PyObject * obj0 = 0 ;
24615 char *kwnames[] = {
24616 (char *) "self", NULL
24617 };
24618
24619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24621 if (SWIG_arg_fail(1)) SWIG_fail;
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24625
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24639 PyObject *obj;
24640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24641 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24642 Py_INCREF(obj);
24643 return Py_BuildValue((char *)"");
24644 }
24645 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24646 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24647 return 1;
24648 }
24649
24650
24651 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24652 PyObject *pyobj;
24653
24654 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24655 return pyobj;
24656 }
24657
24658
24659 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24660 PyObject *resultobj;
24661 wxString *arg1 = 0 ;
24662 wxAcceleratorEntry *result;
24663 bool temp1 = false ;
24664 PyObject * obj0 = 0 ;
24665 char *kwnames[] = {
24666 (char *) "label", NULL
24667 };
24668
24669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24670 {
24671 arg1 = wxString_in_helper(obj0);
24672 if (arg1 == NULL) SWIG_fail;
24673 temp1 = true;
24674 }
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24683 {
24684 if (temp1)
24685 delete arg1;
24686 }
24687 return resultobj;
24688 fail:
24689 {
24690 if (temp1)
24691 delete arg1;
24692 }
24693 return NULL;
24694 }
24695
24696
24697 static int _wrap_PanelNameStr_set(PyObject *) {
24698 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24699 return 1;
24700 }
24701
24702
24703 static PyObject *_wrap_PanelNameStr_get(void) {
24704 PyObject *pyobj;
24705
24706 {
24707 #if wxUSE_UNICODE
24708 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24709 #else
24710 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24711 #endif
24712 }
24713 return pyobj;
24714 }
24715
24716
24717 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24718 PyObject *resultobj;
24719 wxVisualAttributes *result;
24720 char *kwnames[] = {
24721 NULL
24722 };
24723
24724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (wxVisualAttributes *)new_wxVisualAttributes();
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj;
24741 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24742 PyObject * obj0 = 0 ;
24743 char *kwnames[] = {
24744 (char *) "self", NULL
24745 };
24746
24747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24749 if (SWIG_arg_fail(1)) SWIG_fail;
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 delete_wxVisualAttributes(arg1);
24753
24754 wxPyEndAllowThreads(__tstate);
24755 if (PyErr_Occurred()) SWIG_fail;
24756 }
24757 Py_INCREF(Py_None); resultobj = Py_None;
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24767 wxFont *arg2 = (wxFont *) 0 ;
24768 PyObject * obj0 = 0 ;
24769 PyObject * obj1 = 0 ;
24770 char *kwnames[] = {
24771 (char *) "self",(char *) "font", NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24776 if (SWIG_arg_fail(1)) SWIG_fail;
24777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24778 if (SWIG_arg_fail(2)) SWIG_fail;
24779 if (arg1) (arg1)->font = *arg2;
24780
24781 Py_INCREF(Py_None); resultobj = Py_None;
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24791 wxFont *result;
24792 PyObject * obj0 = 0 ;
24793 char *kwnames[] = {
24794 (char *) "self", NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24799 if (SWIG_arg_fail(1)) SWIG_fail;
24800 result = (wxFont *)& ((arg1)->font);
24801
24802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24803 return resultobj;
24804 fail:
24805 return NULL;
24806 }
24807
24808
24809 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24810 PyObject *resultobj;
24811 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24812 wxColour *arg2 = (wxColour *) 0 ;
24813 PyObject * obj0 = 0 ;
24814 PyObject * obj1 = 0 ;
24815 char *kwnames[] = {
24816 (char *) "self",(char *) "colFg", NULL
24817 };
24818
24819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24821 if (SWIG_arg_fail(1)) SWIG_fail;
24822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24823 if (SWIG_arg_fail(2)) SWIG_fail;
24824 if (arg1) (arg1)->colFg = *arg2;
24825
24826 Py_INCREF(Py_None); resultobj = Py_None;
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24834 PyObject *resultobj;
24835 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24836 wxColour *result;
24837 PyObject * obj0 = 0 ;
24838 char *kwnames[] = {
24839 (char *) "self", NULL
24840 };
24841
24842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24844 if (SWIG_arg_fail(1)) SWIG_fail;
24845 result = (wxColour *)& ((arg1)->colFg);
24846
24847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj;
24856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24857 wxColour *arg2 = (wxColour *) 0 ;
24858 PyObject * obj0 = 0 ;
24859 PyObject * obj1 = 0 ;
24860 char *kwnames[] = {
24861 (char *) "self",(char *) "colBg", NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24866 if (SWIG_arg_fail(1)) SWIG_fail;
24867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24868 if (SWIG_arg_fail(2)) SWIG_fail;
24869 if (arg1) (arg1)->colBg = *arg2;
24870
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj;
24880 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24881 wxColour *result;
24882 PyObject * obj0 = 0 ;
24883 char *kwnames[] = {
24884 (char *) "self", NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(1)) SWIG_fail;
24890 result = (wxColour *)& ((arg1)->colBg);
24891
24892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24900 PyObject *obj;
24901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24902 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24903 Py_INCREF(obj);
24904 return Py_BuildValue((char *)"");
24905 }
24906 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj;
24908 wxWindow *arg1 = (wxWindow *) 0 ;
24909 int arg2 = (int) (int)-1 ;
24910 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24911 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24912 wxSize const &arg4_defvalue = wxDefaultSize ;
24913 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24914 long arg5 = (long) 0 ;
24915 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24916 wxString *arg6 = (wxString *) &arg6_defvalue ;
24917 wxWindow *result;
24918 wxPoint temp3 ;
24919 wxSize temp4 ;
24920 bool temp6 = false ;
24921 PyObject * obj0 = 0 ;
24922 PyObject * obj1 = 0 ;
24923 PyObject * obj2 = 0 ;
24924 PyObject * obj3 = 0 ;
24925 PyObject * obj4 = 0 ;
24926 PyObject * obj5 = 0 ;
24927 char *kwnames[] = {
24928 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24933 if (SWIG_arg_fail(1)) SWIG_fail;
24934 if (obj1) {
24935 {
24936 arg2 = (int const)(SWIG_As_int(obj1));
24937 if (SWIG_arg_fail(2)) SWIG_fail;
24938 }
24939 }
24940 if (obj2) {
24941 {
24942 arg3 = &temp3;
24943 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24944 }
24945 }
24946 if (obj3) {
24947 {
24948 arg4 = &temp4;
24949 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24950 }
24951 }
24952 if (obj4) {
24953 {
24954 arg5 = (long)(SWIG_As_long(obj4));
24955 if (SWIG_arg_fail(5)) SWIG_fail;
24956 }
24957 }
24958 if (obj5) {
24959 {
24960 arg6 = wxString_in_helper(obj5);
24961 if (arg6 == NULL) SWIG_fail;
24962 temp6 = true;
24963 }
24964 }
24965 {
24966 if (!wxPyCheckForApp()) SWIG_fail;
24967 PyThreadState* __tstate = wxPyBeginAllowThreads();
24968 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24969
24970 wxPyEndAllowThreads(__tstate);
24971 if (PyErr_Occurred()) SWIG_fail;
24972 }
24973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24974 {
24975 if (temp6)
24976 delete arg6;
24977 }
24978 return resultobj;
24979 fail:
24980 {
24981 if (temp6)
24982 delete arg6;
24983 }
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj;
24990 wxWindow *result;
24991 char *kwnames[] = {
24992 NULL
24993 };
24994
24995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24996 {
24997 if (!wxPyCheckForApp()) SWIG_fail;
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 result = (wxWindow *)new wxWindow();
25000
25001 wxPyEndAllowThreads(__tstate);
25002 if (PyErr_Occurred()) SWIG_fail;
25003 }
25004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj;
25013 wxWindow *arg1 = (wxWindow *) 0 ;
25014 wxWindow *arg2 = (wxWindow *) 0 ;
25015 int arg3 = (int) (int)-1 ;
25016 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25017 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25018 wxSize const &arg5_defvalue = wxDefaultSize ;
25019 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25020 long arg6 = (long) 0 ;
25021 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25022 wxString *arg7 = (wxString *) &arg7_defvalue ;
25023 bool result;
25024 wxPoint temp4 ;
25025 wxSize temp5 ;
25026 bool temp7 = false ;
25027 PyObject * obj0 = 0 ;
25028 PyObject * obj1 = 0 ;
25029 PyObject * obj2 = 0 ;
25030 PyObject * obj3 = 0 ;
25031 PyObject * obj4 = 0 ;
25032 PyObject * obj5 = 0 ;
25033 PyObject * obj6 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25042 if (SWIG_arg_fail(2)) SWIG_fail;
25043 if (obj2) {
25044 {
25045 arg3 = (int const)(SWIG_As_int(obj2));
25046 if (SWIG_arg_fail(3)) SWIG_fail;
25047 }
25048 }
25049 if (obj3) {
25050 {
25051 arg4 = &temp4;
25052 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25053 }
25054 }
25055 if (obj4) {
25056 {
25057 arg5 = &temp5;
25058 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25059 }
25060 }
25061 if (obj5) {
25062 {
25063 arg6 = (long)(SWIG_As_long(obj5));
25064 if (SWIG_arg_fail(6)) SWIG_fail;
25065 }
25066 }
25067 if (obj6) {
25068 {
25069 arg7 = wxString_in_helper(obj6);
25070 if (arg7 == NULL) SWIG_fail;
25071 temp7 = true;
25072 }
25073 }
25074 {
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25077
25078 wxPyEndAllowThreads(__tstate);
25079 if (PyErr_Occurred()) SWIG_fail;
25080 }
25081 {
25082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25083 }
25084 {
25085 if (temp7)
25086 delete arg7;
25087 }
25088 return resultobj;
25089 fail:
25090 {
25091 if (temp7)
25092 delete arg7;
25093 }
25094 return NULL;
25095 }
25096
25097
25098 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj;
25100 wxWindow *arg1 = (wxWindow *) 0 ;
25101 bool arg2 = (bool) false ;
25102 bool result;
25103 PyObject * obj0 = 0 ;
25104 PyObject * obj1 = 0 ;
25105 char *kwnames[] = {
25106 (char *) "self",(char *) "force", NULL
25107 };
25108
25109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25111 if (SWIG_arg_fail(1)) SWIG_fail;
25112 if (obj1) {
25113 {
25114 arg2 = (bool)(SWIG_As_bool(obj1));
25115 if (SWIG_arg_fail(2)) SWIG_fail;
25116 }
25117 }
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = (bool)(arg1)->Close(arg2);
25121
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 {
25126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25127 }
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxWindow *arg1 = (wxWindow *) 0 ;
25137 bool result;
25138 PyObject * obj0 = 0 ;
25139 char *kwnames[] = {
25140 (char *) "self", NULL
25141 };
25142
25143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 result = (bool)(arg1)->Destroy();
25149
25150 wxPyEndAllowThreads(__tstate);
25151 if (PyErr_Occurred()) SWIG_fail;
25152 }
25153 {
25154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25155 }
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj;
25164 wxWindow *arg1 = (wxWindow *) 0 ;
25165 bool result;
25166 PyObject * obj0 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = (bool)(arg1)->DestroyChildren();
25177
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj;
25192 wxWindow *arg1 = (wxWindow *) 0 ;
25193 bool result;
25194 PyObject * obj0 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "self", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 {
25210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25211 }
25212 return resultobj;
25213 fail:
25214 return NULL;
25215 }
25216
25217
25218 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj;
25220 wxWindow *arg1 = (wxWindow *) 0 ;
25221 wxString *arg2 = 0 ;
25222 bool temp2 = false ;
25223 PyObject * obj0 = 0 ;
25224 PyObject * obj1 = 0 ;
25225 char *kwnames[] = {
25226 (char *) "self",(char *) "title", NULL
25227 };
25228
25229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25231 if (SWIG_arg_fail(1)) SWIG_fail;
25232 {
25233 arg2 = wxString_in_helper(obj1);
25234 if (arg2 == NULL) SWIG_fail;
25235 temp2 = true;
25236 }
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 (arg1)->SetTitle((wxString const &)*arg2);
25240
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 Py_INCREF(Py_None); resultobj = Py_None;
25245 {
25246 if (temp2)
25247 delete arg2;
25248 }
25249 return resultobj;
25250 fail:
25251 {
25252 if (temp2)
25253 delete arg2;
25254 }
25255 return NULL;
25256 }
25257
25258
25259 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj;
25261 wxWindow *arg1 = (wxWindow *) 0 ;
25262 wxString result;
25263 PyObject * obj0 = 0 ;
25264 char *kwnames[] = {
25265 (char *) "self", NULL
25266 };
25267
25268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25270 if (SWIG_arg_fail(1)) SWIG_fail;
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = ((wxWindow const *)arg1)->GetTitle();
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 {
25279 #if wxUSE_UNICODE
25280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25281 #else
25282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25283 #endif
25284 }
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25292 PyObject *resultobj;
25293 wxWindow *arg1 = (wxWindow *) 0 ;
25294 wxString *arg2 = 0 ;
25295 bool temp2 = false ;
25296 PyObject * obj0 = 0 ;
25297 PyObject * obj1 = 0 ;
25298 char *kwnames[] = {
25299 (char *) "self",(char *) "label", NULL
25300 };
25301
25302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25304 if (SWIG_arg_fail(1)) SWIG_fail;
25305 {
25306 arg2 = wxString_in_helper(obj1);
25307 if (arg2 == NULL) SWIG_fail;
25308 temp2 = true;
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 (arg1)->SetLabel((wxString const &)*arg2);
25313
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 Py_INCREF(Py_None); resultobj = Py_None;
25318 {
25319 if (temp2)
25320 delete arg2;
25321 }
25322 return resultobj;
25323 fail:
25324 {
25325 if (temp2)
25326 delete arg2;
25327 }
25328 return NULL;
25329 }
25330
25331
25332 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj;
25334 wxWindow *arg1 = (wxWindow *) 0 ;
25335 wxString result;
25336 PyObject * obj0 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "self", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25343 if (SWIG_arg_fail(1)) SWIG_fail;
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = ((wxWindow const *)arg1)->GetLabel();
25347
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 {
25352 #if wxUSE_UNICODE
25353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25354 #else
25355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25356 #endif
25357 }
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 wxWindow *arg1 = (wxWindow *) 0 ;
25367 wxString *arg2 = 0 ;
25368 bool temp2 = false ;
25369 PyObject * obj0 = 0 ;
25370 PyObject * obj1 = 0 ;
25371 char *kwnames[] = {
25372 (char *) "self",(char *) "name", NULL
25373 };
25374
25375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 {
25379 arg2 = wxString_in_helper(obj1);
25380 if (arg2 == NULL) SWIG_fail;
25381 temp2 = true;
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 (arg1)->SetName((wxString const &)*arg2);
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 Py_INCREF(Py_None); resultobj = Py_None;
25391 {
25392 if (temp2)
25393 delete arg2;
25394 }
25395 return resultobj;
25396 fail:
25397 {
25398 if (temp2)
25399 delete arg2;
25400 }
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 wxWindow *arg1 = (wxWindow *) 0 ;
25408 wxString result;
25409 PyObject * obj0 = 0 ;
25410 char *kwnames[] = {
25411 (char *) "self", NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25416 if (SWIG_arg_fail(1)) SWIG_fail;
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = ((wxWindow const *)arg1)->GetName();
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 {
25425 #if wxUSE_UNICODE
25426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25427 #else
25428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25429 #endif
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj;
25439 wxWindow *arg1 = (wxWindow *) 0 ;
25440 wxWindowVariant arg2 ;
25441 PyObject * obj0 = 0 ;
25442 PyObject * obj1 = 0 ;
25443 char *kwnames[] = {
25444 (char *) "self",(char *) "variant", NULL
25445 };
25446
25447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25449 if (SWIG_arg_fail(1)) SWIG_fail;
25450 {
25451 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25452 if (SWIG_arg_fail(2)) SWIG_fail;
25453 }
25454 {
25455 PyThreadState* __tstate = wxPyBeginAllowThreads();
25456 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25457
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 Py_INCREF(Py_None); resultobj = Py_None;
25462 return resultobj;
25463 fail:
25464 return NULL;
25465 }
25466
25467
25468 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25469 PyObject *resultobj;
25470 wxWindow *arg1 = (wxWindow *) 0 ;
25471 wxWindowVariant result;
25472 PyObject * obj0 = 0 ;
25473 char *kwnames[] = {
25474 (char *) "self", NULL
25475 };
25476
25477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25479 if (SWIG_arg_fail(1)) SWIG_fail;
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25483
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_From_int((result));
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj;
25496 wxWindow *arg1 = (wxWindow *) 0 ;
25497 int arg2 ;
25498 PyObject * obj0 = 0 ;
25499 PyObject * obj1 = 0 ;
25500 char *kwnames[] = {
25501 (char *) "self",(char *) "winid", NULL
25502 };
25503
25504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25506 if (SWIG_arg_fail(1)) SWIG_fail;
25507 {
25508 arg2 = (int)(SWIG_As_int(obj1));
25509 if (SWIG_arg_fail(2)) SWIG_fail;
25510 }
25511 {
25512 PyThreadState* __tstate = wxPyBeginAllowThreads();
25513 (arg1)->SetId(arg2);
25514
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 Py_INCREF(Py_None); resultobj = Py_None;
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25526 PyObject *resultobj;
25527 wxWindow *arg1 = (wxWindow *) 0 ;
25528 int result;
25529 PyObject * obj0 = 0 ;
25530 char *kwnames[] = {
25531 (char *) "self", NULL
25532 };
25533
25534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25536 if (SWIG_arg_fail(1)) SWIG_fail;
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 result = (int)((wxWindow const *)arg1)->GetId();
25540
25541 wxPyEndAllowThreads(__tstate);
25542 if (PyErr_Occurred()) SWIG_fail;
25543 }
25544 {
25545 resultobj = SWIG_From_int((int)(result));
25546 }
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25554 PyObject *resultobj;
25555 int result;
25556 char *kwnames[] = {
25557 NULL
25558 };
25559
25560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (int)wxWindow::NewControlId();
25564
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 {
25569 resultobj = SWIG_From_int((int)(result));
25570 }
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 int arg1 ;
25580 int result;
25581 PyObject * obj0 = 0 ;
25582 char *kwnames[] = {
25583 (char *) "winid", NULL
25584 };
25585
25586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25587 {
25588 arg1 = (int)(SWIG_As_int(obj0));
25589 if (SWIG_arg_fail(1)) SWIG_fail;
25590 }
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (int)wxWindow::NextControlId(arg1);
25594
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 resultobj = SWIG_From_int((int)(result));
25600 }
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25608 PyObject *resultobj;
25609 int arg1 ;
25610 int result;
25611 PyObject * obj0 = 0 ;
25612 char *kwnames[] = {
25613 (char *) "winid", NULL
25614 };
25615
25616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25617 {
25618 arg1 = (int)(SWIG_As_int(obj0));
25619 if (SWIG_arg_fail(1)) SWIG_fail;
25620 }
25621 {
25622 PyThreadState* __tstate = wxPyBeginAllowThreads();
25623 result = (int)wxWindow::PrevControlId(arg1);
25624
25625 wxPyEndAllowThreads(__tstate);
25626 if (PyErr_Occurred()) SWIG_fail;
25627 }
25628 {
25629 resultobj = SWIG_From_int((int)(result));
25630 }
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25638 PyObject *resultobj;
25639 wxWindow *arg1 = (wxWindow *) 0 ;
25640 wxSize *arg2 = 0 ;
25641 wxSize temp2 ;
25642 PyObject * obj0 = 0 ;
25643 PyObject * obj1 = 0 ;
25644 char *kwnames[] = {
25645 (char *) "self",(char *) "size", NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25650 if (SWIG_arg_fail(1)) SWIG_fail;
25651 {
25652 arg2 = &temp2;
25653 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25654 }
25655 {
25656 PyThreadState* __tstate = wxPyBeginAllowThreads();
25657 (arg1)->SetSize((wxSize const &)*arg2);
25658
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 Py_INCREF(Py_None); resultobj = Py_None;
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 wxWindow *arg1 = (wxWindow *) 0 ;
25672 int arg2 ;
25673 int arg3 ;
25674 int arg4 ;
25675 int arg5 ;
25676 int arg6 = (int) wxSIZE_AUTO ;
25677 PyObject * obj0 = 0 ;
25678 PyObject * obj1 = 0 ;
25679 PyObject * obj2 = 0 ;
25680 PyObject * obj3 = 0 ;
25681 PyObject * obj4 = 0 ;
25682 PyObject * obj5 = 0 ;
25683 char *kwnames[] = {
25684 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25685 };
25686
25687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25689 if (SWIG_arg_fail(1)) SWIG_fail;
25690 {
25691 arg2 = (int)(SWIG_As_int(obj1));
25692 if (SWIG_arg_fail(2)) SWIG_fail;
25693 }
25694 {
25695 arg3 = (int)(SWIG_As_int(obj2));
25696 if (SWIG_arg_fail(3)) SWIG_fail;
25697 }
25698 {
25699 arg4 = (int)(SWIG_As_int(obj3));
25700 if (SWIG_arg_fail(4)) SWIG_fail;
25701 }
25702 {
25703 arg5 = (int)(SWIG_As_int(obj4));
25704 if (SWIG_arg_fail(5)) SWIG_fail;
25705 }
25706 if (obj5) {
25707 {
25708 arg6 = (int)(SWIG_As_int(obj5));
25709 if (SWIG_arg_fail(6)) SWIG_fail;
25710 }
25711 }
25712 {
25713 PyThreadState* __tstate = wxPyBeginAllowThreads();
25714 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25715
25716 wxPyEndAllowThreads(__tstate);
25717 if (PyErr_Occurred()) SWIG_fail;
25718 }
25719 Py_INCREF(Py_None); resultobj = Py_None;
25720 return resultobj;
25721 fail:
25722 return NULL;
25723 }
25724
25725
25726 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25727 PyObject *resultobj;
25728 wxWindow *arg1 = (wxWindow *) 0 ;
25729 wxRect *arg2 = 0 ;
25730 int arg3 = (int) wxSIZE_AUTO ;
25731 wxRect temp2 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 PyObject * obj2 = 0 ;
25735 char *kwnames[] = {
25736 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25737 };
25738
25739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25741 if (SWIG_arg_fail(1)) SWIG_fail;
25742 {
25743 arg2 = &temp2;
25744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25745 }
25746 if (obj2) {
25747 {
25748 arg3 = (int)(SWIG_As_int(obj2));
25749 if (SWIG_arg_fail(3)) SWIG_fail;
25750 }
25751 }
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25755
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 Py_INCREF(Py_None); resultobj = Py_None;
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj;
25768 wxWindow *arg1 = (wxWindow *) 0 ;
25769 int arg2 ;
25770 int arg3 ;
25771 PyObject * obj0 = 0 ;
25772 PyObject * obj1 = 0 ;
25773 PyObject * obj2 = 0 ;
25774 char *kwnames[] = {
25775 (char *) "self",(char *) "width",(char *) "height", NULL
25776 };
25777
25778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(1)) SWIG_fail;
25781 {
25782 arg2 = (int)(SWIG_As_int(obj1));
25783 if (SWIG_arg_fail(2)) SWIG_fail;
25784 }
25785 {
25786 arg3 = (int)(SWIG_As_int(obj2));
25787 if (SWIG_arg_fail(3)) SWIG_fail;
25788 }
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 (arg1)->SetSize(arg2,arg3);
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 Py_INCREF(Py_None); resultobj = Py_None;
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25804 PyObject *resultobj;
25805 wxWindow *arg1 = (wxWindow *) 0 ;
25806 wxPoint *arg2 = 0 ;
25807 int arg3 = (int) wxSIZE_USE_EXISTING ;
25808 wxPoint temp2 ;
25809 PyObject * obj0 = 0 ;
25810 PyObject * obj1 = 0 ;
25811 PyObject * obj2 = 0 ;
25812 char *kwnames[] = {
25813 (char *) "self",(char *) "pt",(char *) "flags", NULL
25814 };
25815
25816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25818 if (SWIG_arg_fail(1)) SWIG_fail;
25819 {
25820 arg2 = &temp2;
25821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25822 }
25823 if (obj2) {
25824 {
25825 arg3 = (int)(SWIG_As_int(obj2));
25826 if (SWIG_arg_fail(3)) SWIG_fail;
25827 }
25828 }
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 (arg1)->Move((wxPoint const &)*arg2,arg3);
25832
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 Py_INCREF(Py_None); resultobj = Py_None;
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj;
25845 wxWindow *arg1 = (wxWindow *) 0 ;
25846 int arg2 ;
25847 int arg3 ;
25848 int arg4 = (int) wxSIZE_USE_EXISTING ;
25849 PyObject * obj0 = 0 ;
25850 PyObject * obj1 = 0 ;
25851 PyObject * obj2 = 0 ;
25852 PyObject * obj3 = 0 ;
25853 char *kwnames[] = {
25854 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25855 };
25856
25857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25859 if (SWIG_arg_fail(1)) SWIG_fail;
25860 {
25861 arg2 = (int)(SWIG_As_int(obj1));
25862 if (SWIG_arg_fail(2)) SWIG_fail;
25863 }
25864 {
25865 arg3 = (int)(SWIG_As_int(obj2));
25866 if (SWIG_arg_fail(3)) SWIG_fail;
25867 }
25868 if (obj3) {
25869 {
25870 arg4 = (int)(SWIG_As_int(obj3));
25871 if (SWIG_arg_fail(4)) SWIG_fail;
25872 }
25873 }
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 (arg1)->Move(arg2,arg3,arg4);
25877
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 Py_INCREF(Py_None); resultobj = Py_None;
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj;
25890 wxWindow *arg1 = (wxWindow *) 0 ;
25891 wxSize const &arg2_defvalue = wxDefaultSize ;
25892 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25893 wxSize temp2 ;
25894 PyObject * obj0 = 0 ;
25895 PyObject * obj1 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self",(char *) "size", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 if (obj1) {
25904 {
25905 arg2 = &temp2;
25906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25907 }
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 Py_INCREF(Py_None); resultobj = Py_None;
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxWindow *arg1 = (wxWindow *) 0 ;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 (arg1)->Raise();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 Py_INCREF(Py_None); resultobj = Py_None;
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxWindow *arg1 = (wxWindow *) 0 ;
25951 PyObject * obj0 = 0 ;
25952 char *kwnames[] = {
25953 (char *) "self", NULL
25954 };
25955
25956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(1)) SWIG_fail;
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 (arg1)->Lower();
25962
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 Py_INCREF(Py_None); resultobj = Py_None;
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 wxSize *arg2 = 0 ;
25977 wxSize temp2 ;
25978 PyObject * obj0 = 0 ;
25979 PyObject * obj1 = 0 ;
25980 char *kwnames[] = {
25981 (char *) "self",(char *) "size", NULL
25982 };
25983
25984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25986 if (SWIG_arg_fail(1)) SWIG_fail;
25987 {
25988 arg2 = &temp2;
25989 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25990 }
25991 {
25992 PyThreadState* __tstate = wxPyBeginAllowThreads();
25993 (arg1)->SetClientSize((wxSize const &)*arg2);
25994
25995 wxPyEndAllowThreads(__tstate);
25996 if (PyErr_Occurred()) SWIG_fail;
25997 }
25998 Py_INCREF(Py_None); resultobj = Py_None;
25999 return resultobj;
26000 fail:
26001 return NULL;
26002 }
26003
26004
26005 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26006 PyObject *resultobj;
26007 wxWindow *arg1 = (wxWindow *) 0 ;
26008 int arg2 ;
26009 int arg3 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 PyObject * obj2 = 0 ;
26013 char *kwnames[] = {
26014 (char *) "self",(char *) "width",(char *) "height", NULL
26015 };
26016
26017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26019 if (SWIG_arg_fail(1)) SWIG_fail;
26020 {
26021 arg2 = (int)(SWIG_As_int(obj1));
26022 if (SWIG_arg_fail(2)) SWIG_fail;
26023 }
26024 {
26025 arg3 = (int)(SWIG_As_int(obj2));
26026 if (SWIG_arg_fail(3)) SWIG_fail;
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 (arg1)->SetClientSize(arg2,arg3);
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 Py_INCREF(Py_None); resultobj = Py_None;
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj;
26044 wxWindow *arg1 = (wxWindow *) 0 ;
26045 wxRect *arg2 = 0 ;
26046 wxRect temp2 ;
26047 PyObject * obj0 = 0 ;
26048 PyObject * obj1 = 0 ;
26049 char *kwnames[] = {
26050 (char *) "self",(char *) "rect", NULL
26051 };
26052
26053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26055 if (SWIG_arg_fail(1)) SWIG_fail;
26056 {
26057 arg2 = &temp2;
26058 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26059 }
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 (arg1)->SetClientSize((wxRect const &)*arg2);
26063
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 Py_INCREF(Py_None); resultobj = Py_None;
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj;
26076 wxWindow *arg1 = (wxWindow *) 0 ;
26077 wxPoint result;
26078 PyObject * obj0 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = (arg1)->GetPosition();
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 wxPoint * resultptr;
26095 resultptr = new wxPoint((wxPoint &)(result));
26096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26097 }
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 int *arg2 = (int *) 0 ;
26108 int *arg3 = (int *) 0 ;
26109 int temp2 ;
26110 int res2 = 0 ;
26111 int temp3 ;
26112 int res3 = 0 ;
26113 PyObject * obj0 = 0 ;
26114 char *kwnames[] = {
26115 (char *) "self", NULL
26116 };
26117
26118 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26119 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26122 if (SWIG_arg_fail(1)) SWIG_fail;
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 (arg1)->GetPosition(arg2,arg3);
26126
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 Py_INCREF(Py_None); resultobj = Py_None;
26131 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26132 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26133 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26134 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj;
26143 wxWindow *arg1 = (wxWindow *) 0 ;
26144 wxSize result;
26145 PyObject * obj0 = 0 ;
26146 char *kwnames[] = {
26147 (char *) "self", NULL
26148 };
26149
26150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26152 if (SWIG_arg_fail(1)) SWIG_fail;
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 result = ((wxWindow const *)arg1)->GetSize();
26156
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 {
26161 wxSize * resultptr;
26162 resultptr = new wxSize((wxSize &)(result));
26163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26164 }
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26172 PyObject *resultobj;
26173 wxWindow *arg1 = (wxWindow *) 0 ;
26174 int *arg2 = (int *) 0 ;
26175 int *arg3 = (int *) 0 ;
26176 int temp2 ;
26177 int res2 = 0 ;
26178 int temp3 ;
26179 int res3 = 0 ;
26180 PyObject * obj0 = 0 ;
26181 char *kwnames[] = {
26182 (char *) "self", NULL
26183 };
26184
26185 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26186 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26189 if (SWIG_arg_fail(1)) SWIG_fail;
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 Py_INCREF(Py_None); resultobj = Py_None;
26198 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26199 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26200 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26201 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj;
26210 wxWindow *arg1 = (wxWindow *) 0 ;
26211 wxRect result;
26212 PyObject * obj0 = 0 ;
26213 char *kwnames[] = {
26214 (char *) "self", NULL
26215 };
26216
26217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26219 if (SWIG_arg_fail(1)) SWIG_fail;
26220 {
26221 PyThreadState* __tstate = wxPyBeginAllowThreads();
26222 result = ((wxWindow const *)arg1)->GetRect();
26223
26224 wxPyEndAllowThreads(__tstate);
26225 if (PyErr_Occurred()) SWIG_fail;
26226 }
26227 {
26228 wxRect * resultptr;
26229 resultptr = new wxRect((wxRect &)(result));
26230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26231 }
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj;
26240 wxWindow *arg1 = (wxWindow *) 0 ;
26241 wxSize result;
26242 PyObject * obj0 = 0 ;
26243 char *kwnames[] = {
26244 (char *) "self", NULL
26245 };
26246
26247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26249 if (SWIG_arg_fail(1)) SWIG_fail;
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = ((wxWindow const *)arg1)->GetClientSize();
26253
26254 wxPyEndAllowThreads(__tstate);
26255 if (PyErr_Occurred()) SWIG_fail;
26256 }
26257 {
26258 wxSize * resultptr;
26259 resultptr = new wxSize((wxSize &)(result));
26260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26261 }
26262 return resultobj;
26263 fail:
26264 return NULL;
26265 }
26266
26267
26268 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26269 PyObject *resultobj;
26270 wxWindow *arg1 = (wxWindow *) 0 ;
26271 int *arg2 = (int *) 0 ;
26272 int *arg3 = (int *) 0 ;
26273 int temp2 ;
26274 int res2 = 0 ;
26275 int temp3 ;
26276 int res3 = 0 ;
26277 PyObject * obj0 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self", NULL
26280 };
26281
26282 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26283 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26286 if (SWIG_arg_fail(1)) SWIG_fail;
26287 {
26288 PyThreadState* __tstate = wxPyBeginAllowThreads();
26289 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26290
26291 wxPyEndAllowThreads(__tstate);
26292 if (PyErr_Occurred()) SWIG_fail;
26293 }
26294 Py_INCREF(Py_None); resultobj = Py_None;
26295 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26296 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26297 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26298 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj;
26307 wxWindow *arg1 = (wxWindow *) 0 ;
26308 wxPoint result;
26309 PyObject * obj0 = 0 ;
26310 char *kwnames[] = {
26311 (char *) "self", NULL
26312 };
26313
26314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26316 if (SWIG_arg_fail(1)) SWIG_fail;
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26320
26321 wxPyEndAllowThreads(__tstate);
26322 if (PyErr_Occurred()) SWIG_fail;
26323 }
26324 {
26325 wxPoint * resultptr;
26326 resultptr = new wxPoint((wxPoint &)(result));
26327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26328 }
26329 return resultobj;
26330 fail:
26331 return NULL;
26332 }
26333
26334
26335 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26336 PyObject *resultobj;
26337 wxWindow *arg1 = (wxWindow *) 0 ;
26338 wxRect result;
26339 PyObject * obj0 = 0 ;
26340 char *kwnames[] = {
26341 (char *) "self", NULL
26342 };
26343
26344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26346 if (SWIG_arg_fail(1)) SWIG_fail;
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = ((wxWindow const *)arg1)->GetClientRect();
26350
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 {
26355 wxRect * resultptr;
26356 resultptr = new wxRect((wxRect &)(result));
26357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26358 }
26359 return resultobj;
26360 fail:
26361 return NULL;
26362 }
26363
26364
26365 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj;
26367 wxWindow *arg1 = (wxWindow *) 0 ;
26368 wxSize result;
26369 PyObject * obj0 = 0 ;
26370 char *kwnames[] = {
26371 (char *) "self", NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = ((wxWindow const *)arg1)->GetBestSize();
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 wxSize * resultptr;
26386 resultptr = new wxSize((wxSize &)(result));
26387 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26388 }
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxWindow *arg1 = (wxWindow *) 0 ;
26398 int *arg2 = (int *) 0 ;
26399 int *arg3 = (int *) 0 ;
26400 int temp2 ;
26401 int res2 = 0 ;
26402 int temp3 ;
26403 int res3 = 0 ;
26404 PyObject * obj0 = 0 ;
26405 char *kwnames[] = {
26406 (char *) "self", NULL
26407 };
26408
26409 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26410 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26413 if (SWIG_arg_fail(1)) SWIG_fail;
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26417
26418 wxPyEndAllowThreads(__tstate);
26419 if (PyErr_Occurred()) SWIG_fail;
26420 }
26421 Py_INCREF(Py_None); resultobj = Py_None;
26422 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26423 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26424 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26425 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26426 return resultobj;
26427 fail:
26428 return NULL;
26429 }
26430
26431
26432 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj;
26434 wxWindow *arg1 = (wxWindow *) 0 ;
26435 PyObject * obj0 = 0 ;
26436 char *kwnames[] = {
26437 (char *) "self", NULL
26438 };
26439
26440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26442 if (SWIG_arg_fail(1)) SWIG_fail;
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->InvalidateBestSize();
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 wxSize result;
26461 PyObject * obj0 = 0 ;
26462 char *kwnames[] = {
26463 (char *) "self", NULL
26464 };
26465
26466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26468 if (SWIG_arg_fail(1)) SWIG_fail;
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 {
26477 wxSize * resultptr;
26478 resultptr = new wxSize((wxSize &)(result));
26479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26480 }
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 wxSize result;
26491 PyObject * obj0 = 0 ;
26492 char *kwnames[] = {
26493 (char *) "self", NULL
26494 };
26495
26496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26498 if (SWIG_arg_fail(1)) SWIG_fail;
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26502
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 {
26507 wxSize * resultptr;
26508 resultptr = new wxSize((wxSize &)(result));
26509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26510 }
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj;
26519 wxWindow *arg1 = (wxWindow *) 0 ;
26520 int arg2 = (int) wxBOTH ;
26521 PyObject * obj0 = 0 ;
26522 PyObject * obj1 = 0 ;
26523 char *kwnames[] = {
26524 (char *) "self",(char *) "direction", NULL
26525 };
26526
26527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26529 if (SWIG_arg_fail(1)) SWIG_fail;
26530 if (obj1) {
26531 {
26532 arg2 = (int)(SWIG_As_int(obj1));
26533 if (SWIG_arg_fail(2)) SWIG_fail;
26534 }
26535 }
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 (arg1)->Center(arg2);
26539
26540 wxPyEndAllowThreads(__tstate);
26541 if (PyErr_Occurred()) SWIG_fail;
26542 }
26543 Py_INCREF(Py_None); resultobj = Py_None;
26544 return resultobj;
26545 fail:
26546 return NULL;
26547 }
26548
26549
26550 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26551 PyObject *resultobj;
26552 wxWindow *arg1 = (wxWindow *) 0 ;
26553 int arg2 = (int) wxBOTH ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char *kwnames[] = {
26557 (char *) "self",(char *) "dir", NULL
26558 };
26559
26560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26562 if (SWIG_arg_fail(1)) SWIG_fail;
26563 if (obj1) {
26564 {
26565 arg2 = (int)(SWIG_As_int(obj1));
26566 if (SWIG_arg_fail(2)) SWIG_fail;
26567 }
26568 }
26569 {
26570 PyThreadState* __tstate = wxPyBeginAllowThreads();
26571 (arg1)->CenterOnScreen(arg2);
26572
26573 wxPyEndAllowThreads(__tstate);
26574 if (PyErr_Occurred()) SWIG_fail;
26575 }
26576 Py_INCREF(Py_None); resultobj = Py_None;
26577 return resultobj;
26578 fail:
26579 return NULL;
26580 }
26581
26582
26583 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj;
26585 wxWindow *arg1 = (wxWindow *) 0 ;
26586 int arg2 = (int) wxBOTH ;
26587 PyObject * obj0 = 0 ;
26588 PyObject * obj1 = 0 ;
26589 char *kwnames[] = {
26590 (char *) "self",(char *) "dir", NULL
26591 };
26592
26593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26595 if (SWIG_arg_fail(1)) SWIG_fail;
26596 if (obj1) {
26597 {
26598 arg2 = (int)(SWIG_As_int(obj1));
26599 if (SWIG_arg_fail(2)) SWIG_fail;
26600 }
26601 }
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 (arg1)->CenterOnParent(arg2);
26605
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 Py_INCREF(Py_None); resultobj = Py_None;
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj;
26618 wxWindow *arg1 = (wxWindow *) 0 ;
26619 PyObject * obj0 = 0 ;
26620 char *kwnames[] = {
26621 (char *) "self", NULL
26622 };
26623
26624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26626 if (SWIG_arg_fail(1)) SWIG_fail;
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 (arg1)->Fit();
26630
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 Py_INCREF(Py_None); resultobj = Py_None;
26635 return resultobj;
26636 fail:
26637 return NULL;
26638 }
26639
26640
26641 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26642 PyObject *resultobj;
26643 wxWindow *arg1 = (wxWindow *) 0 ;
26644 PyObject * obj0 = 0 ;
26645 char *kwnames[] = {
26646 (char *) "self", NULL
26647 };
26648
26649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26651 if (SWIG_arg_fail(1)) SWIG_fail;
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 (arg1)->FitInside();
26655
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 Py_INCREF(Py_None); resultobj = Py_None;
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj;
26668 wxWindow *arg1 = (wxWindow *) 0 ;
26669 int arg2 ;
26670 int arg3 ;
26671 int arg4 = (int) -1 ;
26672 int arg5 = (int) -1 ;
26673 int arg6 = (int) -1 ;
26674 int arg7 = (int) -1 ;
26675 PyObject * obj0 = 0 ;
26676 PyObject * obj1 = 0 ;
26677 PyObject * obj2 = 0 ;
26678 PyObject * obj3 = 0 ;
26679 PyObject * obj4 = 0 ;
26680 PyObject * obj5 = 0 ;
26681 PyObject * obj6 = 0 ;
26682 char *kwnames[] = {
26683 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26684 };
26685
26686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26688 if (SWIG_arg_fail(1)) SWIG_fail;
26689 {
26690 arg2 = (int)(SWIG_As_int(obj1));
26691 if (SWIG_arg_fail(2)) SWIG_fail;
26692 }
26693 {
26694 arg3 = (int)(SWIG_As_int(obj2));
26695 if (SWIG_arg_fail(3)) SWIG_fail;
26696 }
26697 if (obj3) {
26698 {
26699 arg4 = (int)(SWIG_As_int(obj3));
26700 if (SWIG_arg_fail(4)) SWIG_fail;
26701 }
26702 }
26703 if (obj4) {
26704 {
26705 arg5 = (int)(SWIG_As_int(obj4));
26706 if (SWIG_arg_fail(5)) SWIG_fail;
26707 }
26708 }
26709 if (obj5) {
26710 {
26711 arg6 = (int)(SWIG_As_int(obj5));
26712 if (SWIG_arg_fail(6)) SWIG_fail;
26713 }
26714 }
26715 if (obj6) {
26716 {
26717 arg7 = (int)(SWIG_As_int(obj6));
26718 if (SWIG_arg_fail(7)) SWIG_fail;
26719 }
26720 }
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26724
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 Py_INCREF(Py_None); resultobj = Py_None;
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize *arg2 = 0 ;
26739 wxSize const &arg3_defvalue = wxDefaultSize ;
26740 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26741 wxSize const &arg4_defvalue = wxDefaultSize ;
26742 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26743 wxSize temp2 ;
26744 wxSize temp3 ;
26745 wxSize temp4 ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 PyObject * obj2 = 0 ;
26749 PyObject * obj3 = 0 ;
26750 char *kwnames[] = {
26751 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26752 };
26753
26754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26756 if (SWIG_arg_fail(1)) SWIG_fail;
26757 {
26758 arg2 = &temp2;
26759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26760 }
26761 if (obj2) {
26762 {
26763 arg3 = &temp3;
26764 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26765 }
26766 }
26767 if (obj3) {
26768 {
26769 arg4 = &temp4;
26770 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26771 }
26772 }
26773 {
26774 PyThreadState* __tstate = wxPyBeginAllowThreads();
26775 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26776
26777 wxPyEndAllowThreads(__tstate);
26778 if (PyErr_Occurred()) SWIG_fail;
26779 }
26780 Py_INCREF(Py_None); resultobj = Py_None;
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj;
26789 wxWindow *arg1 = (wxWindow *) 0 ;
26790 int arg2 ;
26791 int arg3 ;
26792 int arg4 = (int) -1 ;
26793 int arg5 = (int) -1 ;
26794 PyObject * obj0 = 0 ;
26795 PyObject * obj1 = 0 ;
26796 PyObject * obj2 = 0 ;
26797 PyObject * obj3 = 0 ;
26798 PyObject * obj4 = 0 ;
26799 char *kwnames[] = {
26800 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26801 };
26802
26803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26805 if (SWIG_arg_fail(1)) SWIG_fail;
26806 {
26807 arg2 = (int)(SWIG_As_int(obj1));
26808 if (SWIG_arg_fail(2)) SWIG_fail;
26809 }
26810 {
26811 arg3 = (int)(SWIG_As_int(obj2));
26812 if (SWIG_arg_fail(3)) SWIG_fail;
26813 }
26814 if (obj3) {
26815 {
26816 arg4 = (int)(SWIG_As_int(obj3));
26817 if (SWIG_arg_fail(4)) SWIG_fail;
26818 }
26819 }
26820 if (obj4) {
26821 {
26822 arg5 = (int)(SWIG_As_int(obj4));
26823 if (SWIG_arg_fail(5)) SWIG_fail;
26824 }
26825 }
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26829
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 Py_INCREF(Py_None); resultobj = Py_None;
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj;
26842 wxWindow *arg1 = (wxWindow *) 0 ;
26843 wxSize *arg2 = 0 ;
26844 wxSize const &arg3_defvalue = wxDefaultSize ;
26845 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26846 wxSize temp2 ;
26847 wxSize temp3 ;
26848 PyObject * obj0 = 0 ;
26849 PyObject * obj1 = 0 ;
26850 PyObject * obj2 = 0 ;
26851 char *kwnames[] = {
26852 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26853 };
26854
26855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26857 if (SWIG_arg_fail(1)) SWIG_fail;
26858 {
26859 arg2 = &temp2;
26860 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26861 }
26862 if (obj2) {
26863 {
26864 arg3 = &temp3;
26865 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26866 }
26867 }
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26871
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 Py_INCREF(Py_None); resultobj = Py_None;
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj;
26884 wxWindow *arg1 = (wxWindow *) 0 ;
26885 wxSize result;
26886 PyObject * obj0 = 0 ;
26887 char *kwnames[] = {
26888 (char *) "self", NULL
26889 };
26890
26891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26893 if (SWIG_arg_fail(1)) SWIG_fail;
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 result = ((wxWindow const *)arg1)->GetMaxSize();
26897
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 {
26902 wxSize * resultptr;
26903 resultptr = new wxSize((wxSize &)(result));
26904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26905 }
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26913 PyObject *resultobj;
26914 wxWindow *arg1 = (wxWindow *) 0 ;
26915 wxSize result;
26916 PyObject * obj0 = 0 ;
26917 char *kwnames[] = {
26918 (char *) "self", NULL
26919 };
26920
26921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26923 if (SWIG_arg_fail(1)) SWIG_fail;
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 result = ((wxWindow const *)arg1)->GetMinSize();
26927
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 wxSize * resultptr;
26933 resultptr = new wxSize((wxSize &)(result));
26934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26935 }
26936 return resultobj;
26937 fail:
26938 return NULL;
26939 }
26940
26941
26942 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26943 PyObject *resultobj;
26944 wxWindow *arg1 = (wxWindow *) 0 ;
26945 wxSize *arg2 = 0 ;
26946 wxSize temp2 ;
26947 PyObject * obj0 = 0 ;
26948 PyObject * obj1 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self",(char *) "minSize", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26955 if (SWIG_arg_fail(1)) SWIG_fail;
26956 {
26957 arg2 = &temp2;
26958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26959 }
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 (arg1)->SetMinSize((wxSize const &)*arg2);
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 Py_INCREF(Py_None); resultobj = Py_None;
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj;
26976 wxWindow *arg1 = (wxWindow *) 0 ;
26977 wxSize *arg2 = 0 ;
26978 wxSize temp2 ;
26979 PyObject * obj0 = 0 ;
26980 PyObject * obj1 = 0 ;
26981 char *kwnames[] = {
26982 (char *) "self",(char *) "maxSize", NULL
26983 };
26984
26985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26987 if (SWIG_arg_fail(1)) SWIG_fail;
26988 {
26989 arg2 = &temp2;
26990 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 (arg1)->SetMaxSize((wxSize const &)*arg2);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 Py_INCREF(Py_None); resultobj = Py_None;
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27007 PyObject *resultobj;
27008 wxWindow *arg1 = (wxWindow *) 0 ;
27009 int result;
27010 PyObject * obj0 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self", NULL
27013 };
27014
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27017 if (SWIG_arg_fail(1)) SWIG_fail;
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27021
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 {
27026 resultobj = SWIG_From_int((int)(result));
27027 }
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27035 PyObject *resultobj;
27036 wxWindow *arg1 = (wxWindow *) 0 ;
27037 int result;
27038 PyObject * obj0 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 resultobj = SWIG_From_int((int)(result));
27055 }
27056 return resultobj;
27057 fail:
27058 return NULL;
27059 }
27060
27061
27062 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27063 PyObject *resultobj;
27064 wxWindow *arg1 = (wxWindow *) 0 ;
27065 int result;
27066 PyObject * obj0 = 0 ;
27067 char *kwnames[] = {
27068 (char *) "self", NULL
27069 };
27070
27071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(1)) SWIG_fail;
27074 {
27075 PyThreadState* __tstate = wxPyBeginAllowThreads();
27076 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27077
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 {
27082 resultobj = SWIG_From_int((int)(result));
27083 }
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj;
27092 wxWindow *arg1 = (wxWindow *) 0 ;
27093 int result;
27094 PyObject * obj0 = 0 ;
27095 char *kwnames[] = {
27096 (char *) "self", NULL
27097 };
27098
27099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27101 if (SWIG_arg_fail(1)) SWIG_fail;
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27105
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 resultobj = SWIG_From_int((int)(result));
27111 }
27112 return resultobj;
27113 fail:
27114 return NULL;
27115 }
27116
27117
27118 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27119 PyObject *resultobj;
27120 wxWindow *arg1 = (wxWindow *) 0 ;
27121 wxSize *arg2 = 0 ;
27122 wxSize temp2 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char *kwnames[] = {
27126 (char *) "self",(char *) "size", NULL
27127 };
27128
27129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27131 if (SWIG_arg_fail(1)) SWIG_fail;
27132 {
27133 arg2 = &temp2;
27134 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27135 }
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 Py_INCREF(Py_None); resultobj = Py_None;
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj;
27152 wxWindow *arg1 = (wxWindow *) 0 ;
27153 int arg2 ;
27154 int arg3 ;
27155 PyObject * obj0 = 0 ;
27156 PyObject * obj1 = 0 ;
27157 PyObject * obj2 = 0 ;
27158 char *kwnames[] = {
27159 (char *) "self",(char *) "w",(char *) "h", NULL
27160 };
27161
27162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27164 if (SWIG_arg_fail(1)) SWIG_fail;
27165 {
27166 arg2 = (int)(SWIG_As_int(obj1));
27167 if (SWIG_arg_fail(2)) SWIG_fail;
27168 }
27169 {
27170 arg3 = (int)(SWIG_As_int(obj2));
27171 if (SWIG_arg_fail(3)) SWIG_fail;
27172 }
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 (arg1)->SetVirtualSize(arg2,arg3);
27176
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 Py_INCREF(Py_None); resultobj = Py_None;
27181 return resultobj;
27182 fail:
27183 return NULL;
27184 }
27185
27186
27187 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27188 PyObject *resultobj;
27189 wxWindow *arg1 = (wxWindow *) 0 ;
27190 wxSize result;
27191 PyObject * obj0 = 0 ;
27192 char *kwnames[] = {
27193 (char *) "self", NULL
27194 };
27195
27196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27198 if (SWIG_arg_fail(1)) SWIG_fail;
27199 {
27200 PyThreadState* __tstate = wxPyBeginAllowThreads();
27201 result = ((wxWindow const *)arg1)->GetVirtualSize();
27202
27203 wxPyEndAllowThreads(__tstate);
27204 if (PyErr_Occurred()) SWIG_fail;
27205 }
27206 {
27207 wxSize * resultptr;
27208 resultptr = new wxSize((wxSize &)(result));
27209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27210 }
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj;
27219 wxWindow *arg1 = (wxWindow *) 0 ;
27220 int *arg2 = (int *) 0 ;
27221 int *arg3 = (int *) 0 ;
27222 int temp2 ;
27223 int res2 = 0 ;
27224 int temp3 ;
27225 int res3 = 0 ;
27226 PyObject * obj0 = 0 ;
27227 char *kwnames[] = {
27228 (char *) "self", NULL
27229 };
27230
27231 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27232 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27239
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 Py_INCREF(Py_None); resultobj = Py_None;
27244 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27245 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27246 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27247 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27248 return resultobj;
27249 fail:
27250 return NULL;
27251 }
27252
27253
27254 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27255 PyObject *resultobj;
27256 wxWindow *arg1 = (wxWindow *) 0 ;
27257 wxSize result;
27258 PyObject * obj0 = 0 ;
27259 char *kwnames[] = {
27260 (char *) "self", NULL
27261 };
27262
27263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27265 if (SWIG_arg_fail(1)) SWIG_fail;
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27269
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 {
27274 wxSize * resultptr;
27275 resultptr = new wxSize((wxSize &)(result));
27276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27277 }
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxWindow *arg1 = (wxWindow *) 0 ;
27287 bool arg2 = (bool) true ;
27288 bool result;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 char *kwnames[] = {
27292 (char *) "self",(char *) "show", NULL
27293 };
27294
27295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27297 if (SWIG_arg_fail(1)) SWIG_fail;
27298 if (obj1) {
27299 {
27300 arg2 = (bool)(SWIG_As_bool(obj1));
27301 if (SWIG_arg_fail(2)) SWIG_fail;
27302 }
27303 }
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 result = (bool)(arg1)->Show(arg2);
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27313 }
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj;
27322 wxWindow *arg1 = (wxWindow *) 0 ;
27323 bool result;
27324 PyObject * obj0 = 0 ;
27325 char *kwnames[] = {
27326 (char *) "self", NULL
27327 };
27328
27329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27331 if (SWIG_arg_fail(1)) SWIG_fail;
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 result = (bool)(arg1)->Hide();
27335
27336 wxPyEndAllowThreads(__tstate);
27337 if (PyErr_Occurred()) SWIG_fail;
27338 }
27339 {
27340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27341 }
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj;
27350 wxWindow *arg1 = (wxWindow *) 0 ;
27351 bool arg2 = (bool) true ;
27352 bool result;
27353 PyObject * obj0 = 0 ;
27354 PyObject * obj1 = 0 ;
27355 char *kwnames[] = {
27356 (char *) "self",(char *) "enable", NULL
27357 };
27358
27359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27361 if (SWIG_arg_fail(1)) SWIG_fail;
27362 if (obj1) {
27363 {
27364 arg2 = (bool)(SWIG_As_bool(obj1));
27365 if (SWIG_arg_fail(2)) SWIG_fail;
27366 }
27367 }
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = (bool)(arg1)->Enable(arg2);
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27377 }
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27385 PyObject *resultobj;
27386 wxWindow *arg1 = (wxWindow *) 0 ;
27387 bool result;
27388 PyObject * obj0 = 0 ;
27389 char *kwnames[] = {
27390 (char *) "self", NULL
27391 };
27392
27393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27395 if (SWIG_arg_fail(1)) SWIG_fail;
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 result = (bool)(arg1)->Disable();
27399
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 {
27404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27405 }
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj;
27414 wxWindow *arg1 = (wxWindow *) 0 ;
27415 bool result;
27416 PyObject * obj0 = 0 ;
27417 char *kwnames[] = {
27418 (char *) "self", NULL
27419 };
27420
27421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27423 if (SWIG_arg_fail(1)) SWIG_fail;
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 result = (bool)((wxWindow const *)arg1)->IsShown();
27427
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27433 }
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27441 PyObject *resultobj;
27442 wxWindow *arg1 = (wxWindow *) 0 ;
27443 bool result;
27444 PyObject * obj0 = 0 ;
27445 char *kwnames[] = {
27446 (char *) "self", NULL
27447 };
27448
27449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27451 if (SWIG_arg_fail(1)) SWIG_fail;
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27469 PyObject *resultobj;
27470 wxWindow *arg1 = (wxWindow *) 0 ;
27471 long arg2 ;
27472 PyObject * obj0 = 0 ;
27473 PyObject * obj1 = 0 ;
27474 char *kwnames[] = {
27475 (char *) "self",(char *) "style", NULL
27476 };
27477
27478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27480 if (SWIG_arg_fail(1)) SWIG_fail;
27481 {
27482 arg2 = (long)(SWIG_As_long(obj1));
27483 if (SWIG_arg_fail(2)) SWIG_fail;
27484 }
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 (arg1)->SetWindowStyleFlag(arg2);
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 Py_INCREF(Py_None); resultobj = Py_None;
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27500 PyObject *resultobj;
27501 wxWindow *arg1 = (wxWindow *) 0 ;
27502 long result;
27503 PyObject * obj0 = 0 ;
27504 char *kwnames[] = {
27505 (char *) "self", NULL
27506 };
27507
27508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27510 if (SWIG_arg_fail(1)) SWIG_fail;
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27514
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 {
27519 resultobj = SWIG_From_long((long)(result));
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj;
27529 wxWindow *arg1 = (wxWindow *) 0 ;
27530 int arg2 ;
27531 bool result;
27532 PyObject * obj0 = 0 ;
27533 PyObject * obj1 = 0 ;
27534 char *kwnames[] = {
27535 (char *) "self",(char *) "flag", NULL
27536 };
27537
27538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27540 if (SWIG_arg_fail(1)) SWIG_fail;
27541 {
27542 arg2 = (int)(SWIG_As_int(obj1));
27543 if (SWIG_arg_fail(2)) SWIG_fail;
27544 }
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27548
27549 wxPyEndAllowThreads(__tstate);
27550 if (PyErr_Occurred()) SWIG_fail;
27551 }
27552 {
27553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27554 }
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj;
27563 wxWindow *arg1 = (wxWindow *) 0 ;
27564 bool result;
27565 PyObject * obj0 = 0 ;
27566 char *kwnames[] = {
27567 (char *) "self", NULL
27568 };
27569
27570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27572 if (SWIG_arg_fail(1)) SWIG_fail;
27573 {
27574 PyThreadState* __tstate = wxPyBeginAllowThreads();
27575 result = (bool)((wxWindow const *)arg1)->IsRetained();
27576
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 {
27581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27582 }
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxWindow *arg1 = (wxWindow *) 0 ;
27592 long arg2 ;
27593 PyObject * obj0 = 0 ;
27594 PyObject * obj1 = 0 ;
27595 char *kwnames[] = {
27596 (char *) "self",(char *) "exStyle", NULL
27597 };
27598
27599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27601 if (SWIG_arg_fail(1)) SWIG_fail;
27602 {
27603 arg2 = (long)(SWIG_As_long(obj1));
27604 if (SWIG_arg_fail(2)) SWIG_fail;
27605 }
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 (arg1)->SetExtraStyle(arg2);
27609
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 Py_INCREF(Py_None); resultobj = Py_None;
27614 return resultobj;
27615 fail:
27616 return NULL;
27617 }
27618
27619
27620 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27621 PyObject *resultobj;
27622 wxWindow *arg1 = (wxWindow *) 0 ;
27623 long result;
27624 PyObject * obj0 = 0 ;
27625 char *kwnames[] = {
27626 (char *) "self", NULL
27627 };
27628
27629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27631 if (SWIG_arg_fail(1)) SWIG_fail;
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27635
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 {
27640 resultobj = SWIG_From_long((long)(result));
27641 }
27642 return resultobj;
27643 fail:
27644 return NULL;
27645 }
27646
27647
27648 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27649 PyObject *resultobj;
27650 wxWindow *arg1 = (wxWindow *) 0 ;
27651 bool arg2 = (bool) true ;
27652 PyObject * obj0 = 0 ;
27653 PyObject * obj1 = 0 ;
27654 char *kwnames[] = {
27655 (char *) "self",(char *) "modal", NULL
27656 };
27657
27658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27660 if (SWIG_arg_fail(1)) SWIG_fail;
27661 if (obj1) {
27662 {
27663 arg2 = (bool)(SWIG_As_bool(obj1));
27664 if (SWIG_arg_fail(2)) SWIG_fail;
27665 }
27666 }
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 (arg1)->MakeModal(arg2);
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 Py_INCREF(Py_None); resultobj = Py_None;
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27682 PyObject *resultobj;
27683 wxWindow *arg1 = (wxWindow *) 0 ;
27684 bool arg2 ;
27685 PyObject * obj0 = 0 ;
27686 PyObject * obj1 = 0 ;
27687 char *kwnames[] = {
27688 (char *) "self",(char *) "enableTheme", NULL
27689 };
27690
27691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27693 if (SWIG_arg_fail(1)) SWIG_fail;
27694 {
27695 arg2 = (bool)(SWIG_As_bool(obj1));
27696 if (SWIG_arg_fail(2)) SWIG_fail;
27697 }
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 (arg1)->SetThemeEnabled(arg2);
27701
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 Py_INCREF(Py_None); resultobj = Py_None;
27706 return resultobj;
27707 fail:
27708 return NULL;
27709 }
27710
27711
27712 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27713 PyObject *resultobj;
27714 wxWindow *arg1 = (wxWindow *) 0 ;
27715 bool result;
27716 PyObject * obj0 = 0 ;
27717 char *kwnames[] = {
27718 (char *) "self", NULL
27719 };
27720
27721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27723 if (SWIG_arg_fail(1)) SWIG_fail;
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27727
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 {
27732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27733 }
27734 return resultobj;
27735 fail:
27736 return NULL;
27737 }
27738
27739
27740 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27741 PyObject *resultobj;
27742 wxWindow *arg1 = (wxWindow *) 0 ;
27743 PyObject * obj0 = 0 ;
27744 char *kwnames[] = {
27745 (char *) "self", NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 {
27752 PyThreadState* __tstate = wxPyBeginAllowThreads();
27753 (arg1)->SetFocus();
27754
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 Py_INCREF(Py_None); resultobj = Py_None;
27759 return resultobj;
27760 fail:
27761 return NULL;
27762 }
27763
27764
27765 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27766 PyObject *resultobj;
27767 wxWindow *arg1 = (wxWindow *) 0 ;
27768 PyObject * obj0 = 0 ;
27769 char *kwnames[] = {
27770 (char *) "self", NULL
27771 };
27772
27773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27775 if (SWIG_arg_fail(1)) SWIG_fail;
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 (arg1)->SetFocusFromKbd();
27779
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 Py_INCREF(Py_None); resultobj = Py_None;
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27791 PyObject *resultobj;
27792 wxWindow *result;
27793 char *kwnames[] = {
27794 NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27798 {
27799 if (!wxPyCheckForApp()) SWIG_fail;
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 result = (wxWindow *)wxWindow::FindFocus();
27802
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 {
27807 resultobj = wxPyMake_wxObject(result, 0);
27808 }
27809 return resultobj;
27810 fail:
27811 return NULL;
27812 }
27813
27814
27815 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxWindow *arg1 = (wxWindow *) 0 ;
27818 bool result;
27819 PyObject * obj0 = 0 ;
27820 char *kwnames[] = {
27821 (char *) "self", NULL
27822 };
27823
27824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(1)) SWIG_fail;
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27830
27831 wxPyEndAllowThreads(__tstate);
27832 if (PyErr_Occurred()) SWIG_fail;
27833 }
27834 {
27835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27836 }
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj;
27845 wxWindow *arg1 = (wxWindow *) 0 ;
27846 bool result;
27847 PyObject * obj0 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27854 if (SWIG_arg_fail(1)) SWIG_fail;
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27858
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 {
27863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27864 }
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj;
27873 wxWindow *arg1 = (wxWindow *) 0 ;
27874 wxWindow *result;
27875 PyObject * obj0 = 0 ;
27876 char *kwnames[] = {
27877 (char *) "self", NULL
27878 };
27879
27880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27882 if (SWIG_arg_fail(1)) SWIG_fail;
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27886
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = wxPyMake_wxObject(result, 0);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27900 PyObject *resultobj;
27901 wxWindow *arg1 = (wxWindow *) 0 ;
27902 wxWindow *arg2 = (wxWindow *) 0 ;
27903 wxWindow *result;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 char *kwnames[] = {
27907 (char *) "self",(char *) "child", NULL
27908 };
27909
27910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27912 if (SWIG_arg_fail(1)) SWIG_fail;
27913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27914 if (SWIG_arg_fail(2)) SWIG_fail;
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27918
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = wxPyMake_wxObject(result, 0);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj;
27933 wxWindow *arg1 = (wxWindow *) 0 ;
27934 wxWindow *arg2 = (wxWindow *) 0 ;
27935 PyObject * obj0 = 0 ;
27936 PyObject * obj1 = 0 ;
27937 char *kwnames[] = {
27938 (char *) "self",(char *) "win", NULL
27939 };
27940
27941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27943 if (SWIG_arg_fail(1)) SWIG_fail;
27944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27945 if (SWIG_arg_fail(2)) SWIG_fail;
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 (arg1)->SetTmpDefaultItem(arg2);
27949
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 Py_INCREF(Py_None); resultobj = Py_None;
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj;
27962 wxWindow *arg1 = (wxWindow *) 0 ;
27963 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27964 bool result;
27965 PyObject * obj0 = 0 ;
27966 PyObject * obj1 = 0 ;
27967 char *kwnames[] = {
27968 (char *) "self",(char *) "flags", NULL
27969 };
27970
27971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27973 if (SWIG_arg_fail(1)) SWIG_fail;
27974 if (obj1) {
27975 {
27976 arg2 = (int)(SWIG_As_int(obj1));
27977 if (SWIG_arg_fail(2)) SWIG_fail;
27978 }
27979 }
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 result = (bool)(arg1)->Navigate(arg2);
27983
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 {
27988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27989 }
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj;
27998 wxWindow *arg1 = (wxWindow *) 0 ;
27999 wxWindow *arg2 = (wxWindow *) 0 ;
28000 PyObject * obj0 = 0 ;
28001 PyObject * obj1 = 0 ;
28002 char *kwnames[] = {
28003 (char *) "self",(char *) "win", NULL
28004 };
28005
28006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28008 if (SWIG_arg_fail(1)) SWIG_fail;
28009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28010 if (SWIG_arg_fail(2)) SWIG_fail;
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 (arg1)->MoveAfterInTabOrder(arg2);
28014
28015 wxPyEndAllowThreads(__tstate);
28016 if (PyErr_Occurred()) SWIG_fail;
28017 }
28018 Py_INCREF(Py_None); resultobj = Py_None;
28019 return resultobj;
28020 fail:
28021 return NULL;
28022 }
28023
28024
28025 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28026 PyObject *resultobj;
28027 wxWindow *arg1 = (wxWindow *) 0 ;
28028 wxWindow *arg2 = (wxWindow *) 0 ;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031 char *kwnames[] = {
28032 (char *) "self",(char *) "win", NULL
28033 };
28034
28035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28037 if (SWIG_arg_fail(1)) SWIG_fail;
28038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28039 if (SWIG_arg_fail(2)) SWIG_fail;
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 (arg1)->MoveBeforeInTabOrder(arg2);
28043
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 Py_INCREF(Py_None); resultobj = Py_None;
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28055 PyObject *resultobj;
28056 wxWindow *arg1 = (wxWindow *) 0 ;
28057 PyObject *result;
28058 PyObject * obj0 = 0 ;
28059 char *kwnames[] = {
28060 (char *) "self", NULL
28061 };
28062
28063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (PyObject *)wxWindow_GetChildren(arg1);
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 resultobj = result;
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj;
28082 wxWindow *arg1 = (wxWindow *) 0 ;
28083 wxWindow *result;
28084 PyObject * obj0 = 0 ;
28085 char *kwnames[] = {
28086 (char *) "self", NULL
28087 };
28088
28089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28091 if (SWIG_arg_fail(1)) SWIG_fail;
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28095
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 {
28100 resultobj = wxPyMake_wxObject(result, 0);
28101 }
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 wxWindow *result;
28112 PyObject * obj0 = 0 ;
28113 char *kwnames[] = {
28114 (char *) "self", NULL
28115 };
28116
28117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28119 if (SWIG_arg_fail(1)) SWIG_fail;
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = wxPyMake_wxObject(result, 0);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj;
28138 wxWindow *arg1 = (wxWindow *) 0 ;
28139 bool result;
28140 PyObject * obj0 = 0 ;
28141 char *kwnames[] = {
28142 (char *) "self", NULL
28143 };
28144
28145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28147 if (SWIG_arg_fail(1)) SWIG_fail;
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28151
28152 wxPyEndAllowThreads(__tstate);
28153 if (PyErr_Occurred()) SWIG_fail;
28154 }
28155 {
28156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28157 }
28158 return resultobj;
28159 fail:
28160 return NULL;
28161 }
28162
28163
28164 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28165 PyObject *resultobj;
28166 wxWindow *arg1 = (wxWindow *) 0 ;
28167 wxWindow *arg2 = (wxWindow *) 0 ;
28168 bool result;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char *kwnames[] = {
28172 (char *) "self",(char *) "newParent", NULL
28173 };
28174
28175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28177 if (SWIG_arg_fail(1)) SWIG_fail;
28178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28179 if (SWIG_arg_fail(2)) SWIG_fail;
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (bool)(arg1)->Reparent(arg2);
28183
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 {
28188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28189 }
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj;
28198 wxWindow *arg1 = (wxWindow *) 0 ;
28199 wxWindow *arg2 = (wxWindow *) 0 ;
28200 PyObject * obj0 = 0 ;
28201 PyObject * obj1 = 0 ;
28202 char *kwnames[] = {
28203 (char *) "self",(char *) "child", NULL
28204 };
28205
28206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28208 if (SWIG_arg_fail(1)) SWIG_fail;
28209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28210 if (SWIG_arg_fail(2)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 (arg1)->AddChild(arg2);
28214
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 Py_INCREF(Py_None); resultobj = Py_None;
28219 return resultobj;
28220 fail:
28221 return NULL;
28222 }
28223
28224
28225 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28226 PyObject *resultobj;
28227 wxWindow *arg1 = (wxWindow *) 0 ;
28228 wxWindow *arg2 = (wxWindow *) 0 ;
28229 PyObject * obj0 = 0 ;
28230 PyObject * obj1 = 0 ;
28231 char *kwnames[] = {
28232 (char *) "self",(char *) "child", NULL
28233 };
28234
28235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28237 if (SWIG_arg_fail(1)) SWIG_fail;
28238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28239 if (SWIG_arg_fail(2)) SWIG_fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 (arg1)->RemoveChild(arg2);
28243
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 Py_INCREF(Py_None); resultobj = Py_None;
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 long arg2 ;
28258 wxWindow *result;
28259 PyObject * obj0 = 0 ;
28260 PyObject * obj1 = 0 ;
28261 char *kwnames[] = {
28262 (char *) "self",(char *) "winid", NULL
28263 };
28264
28265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28267 if (SWIG_arg_fail(1)) SWIG_fail;
28268 {
28269 arg2 = (long)(SWIG_As_long(obj1));
28270 if (SWIG_arg_fail(2)) SWIG_fail;
28271 }
28272 {
28273 PyThreadState* __tstate = wxPyBeginAllowThreads();
28274 result = (wxWindow *)(arg1)->FindWindow(arg2);
28275
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 {
28280 resultobj = wxPyMake_wxObject(result, 0);
28281 }
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj;
28290 wxWindow *arg1 = (wxWindow *) 0 ;
28291 wxString *arg2 = 0 ;
28292 wxWindow *result;
28293 bool temp2 = false ;
28294 PyObject * obj0 = 0 ;
28295 PyObject * obj1 = 0 ;
28296 char *kwnames[] = {
28297 (char *) "self",(char *) "name", NULL
28298 };
28299
28300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28302 if (SWIG_arg_fail(1)) SWIG_fail;
28303 {
28304 arg2 = wxString_in_helper(obj1);
28305 if (arg2 == NULL) SWIG_fail;
28306 temp2 = true;
28307 }
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28311
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 {
28316 resultobj = wxPyMake_wxObject(result, 0);
28317 }
28318 {
28319 if (temp2)
28320 delete arg2;
28321 }
28322 return resultobj;
28323 fail:
28324 {
28325 if (temp2)
28326 delete arg2;
28327 }
28328 return NULL;
28329 }
28330
28331
28332 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj;
28334 wxWindow *arg1 = (wxWindow *) 0 ;
28335 wxEvtHandler *result;
28336 PyObject * obj0 = 0 ;
28337 char *kwnames[] = {
28338 (char *) "self", NULL
28339 };
28340
28341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28343 if (SWIG_arg_fail(1)) SWIG_fail;
28344 {
28345 PyThreadState* __tstate = wxPyBeginAllowThreads();
28346 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28347
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 {
28352 resultobj = wxPyMake_wxObject(result, 0);
28353 }
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28361 PyObject *resultobj;
28362 wxWindow *arg1 = (wxWindow *) 0 ;
28363 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char *kwnames[] = {
28367 (char *) "self",(char *) "handler", NULL
28368 };
28369
28370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28372 if (SWIG_arg_fail(1)) SWIG_fail;
28373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28374 if (SWIG_arg_fail(2)) SWIG_fail;
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 (arg1)->SetEventHandler(arg2);
28378
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 Py_INCREF(Py_None); resultobj = Py_None;
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28390 PyObject *resultobj;
28391 wxWindow *arg1 = (wxWindow *) 0 ;
28392 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 char *kwnames[] = {
28396 (char *) "self",(char *) "handler", NULL
28397 };
28398
28399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28403 if (SWIG_arg_fail(2)) SWIG_fail;
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 (arg1)->PushEventHandler(arg2);
28407
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 Py_INCREF(Py_None); resultobj = Py_None;
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxWindow *arg1 = (wxWindow *) 0 ;
28421 bool arg2 = (bool) false ;
28422 wxEvtHandler *result;
28423 PyObject * obj0 = 0 ;
28424 PyObject * obj1 = 0 ;
28425 char *kwnames[] = {
28426 (char *) "self",(char *) "deleteHandler", NULL
28427 };
28428
28429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28431 if (SWIG_arg_fail(1)) SWIG_fail;
28432 if (obj1) {
28433 {
28434 arg2 = (bool)(SWIG_As_bool(obj1));
28435 if (SWIG_arg_fail(2)) SWIG_fail;
28436 }
28437 }
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28441
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 {
28446 resultobj = wxPyMake_wxObject(result, 0);
28447 }
28448 return resultobj;
28449 fail:
28450 return NULL;
28451 }
28452
28453
28454 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj;
28456 wxWindow *arg1 = (wxWindow *) 0 ;
28457 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28458 bool result;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self",(char *) "handler", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(2)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)(arg1)->RemoveEventHandler(arg2);
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 wxValidator *arg2 = 0 ;
28490 PyObject * obj0 = 0 ;
28491 PyObject * obj1 = 0 ;
28492 char *kwnames[] = {
28493 (char *) "self",(char *) "validator", NULL
28494 };
28495
28496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28498 if (SWIG_arg_fail(1)) SWIG_fail;
28499 {
28500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28501 if (SWIG_arg_fail(2)) SWIG_fail;
28502 if (arg2 == NULL) {
28503 SWIG_null_ref("wxValidator");
28504 }
28505 if (SWIG_arg_fail(2)) SWIG_fail;
28506 }
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 (arg1)->SetValidator((wxValidator const &)*arg2);
28510
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 Py_INCREF(Py_None); resultobj = Py_None;
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj;
28523 wxWindow *arg1 = (wxWindow *) 0 ;
28524 wxValidator *result;
28525 PyObject * obj0 = 0 ;
28526 char *kwnames[] = {
28527 (char *) "self", NULL
28528 };
28529
28530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28532 if (SWIG_arg_fail(1)) SWIG_fail;
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (wxValidator *)(arg1)->GetValidator();
28536
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 {
28541 resultobj = wxPyMake_wxObject(result, 0);
28542 }
28543 return resultobj;
28544 fail:
28545 return NULL;
28546 }
28547
28548
28549 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28550 PyObject *resultobj;
28551 wxWindow *arg1 = (wxWindow *) 0 ;
28552 bool result;
28553 PyObject * obj0 = 0 ;
28554 char *kwnames[] = {
28555 (char *) "self", NULL
28556 };
28557
28558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28560 if (SWIG_arg_fail(1)) SWIG_fail;
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 result = (bool)(arg1)->Validate();
28564
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 {
28569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28578 PyObject *resultobj;
28579 wxWindow *arg1 = (wxWindow *) 0 ;
28580 bool result;
28581 PyObject * obj0 = 0 ;
28582 char *kwnames[] = {
28583 (char *) "self", NULL
28584 };
28585
28586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28588 if (SWIG_arg_fail(1)) SWIG_fail;
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = (bool)(arg1)->TransferDataToWindow();
28592
28593 wxPyEndAllowThreads(__tstate);
28594 if (PyErr_Occurred()) SWIG_fail;
28595 }
28596 {
28597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28606 PyObject *resultobj;
28607 wxWindow *arg1 = (wxWindow *) 0 ;
28608 bool result;
28609 PyObject * obj0 = 0 ;
28610 char *kwnames[] = {
28611 (char *) "self", NULL
28612 };
28613
28614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28616 if (SWIG_arg_fail(1)) SWIG_fail;
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 result = (bool)(arg1)->TransferDataFromWindow();
28620
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 {
28625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28626 }
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj;
28635 wxWindow *arg1 = (wxWindow *) 0 ;
28636 PyObject * obj0 = 0 ;
28637 char *kwnames[] = {
28638 (char *) "self", NULL
28639 };
28640
28641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28643 if (SWIG_arg_fail(1)) SWIG_fail;
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 (arg1)->InitDialog();
28647
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 Py_INCREF(Py_None); resultobj = Py_None;
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28659 PyObject *resultobj;
28660 wxWindow *arg1 = (wxWindow *) 0 ;
28661 wxAcceleratorTable *arg2 = 0 ;
28662 PyObject * obj0 = 0 ;
28663 PyObject * obj1 = 0 ;
28664 char *kwnames[] = {
28665 (char *) "self",(char *) "accel", NULL
28666 };
28667
28668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28670 if (SWIG_arg_fail(1)) SWIG_fail;
28671 {
28672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28673 if (SWIG_arg_fail(2)) SWIG_fail;
28674 if (arg2 == NULL) {
28675 SWIG_null_ref("wxAcceleratorTable");
28676 }
28677 if (SWIG_arg_fail(2)) SWIG_fail;
28678 }
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 Py_INCREF(Py_None); resultobj = Py_None;
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28694 PyObject *resultobj;
28695 wxWindow *arg1 = (wxWindow *) 0 ;
28696 wxAcceleratorTable *result;
28697 PyObject * obj0 = 0 ;
28698 char *kwnames[] = {
28699 (char *) "self", NULL
28700 };
28701
28702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28704 if (SWIG_arg_fail(1)) SWIG_fail;
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj;
28721 wxWindow *arg1 = (wxWindow *) 0 ;
28722 int arg2 ;
28723 int arg3 ;
28724 int arg4 ;
28725 bool result;
28726 PyObject * obj0 = 0 ;
28727 PyObject * obj1 = 0 ;
28728 PyObject * obj2 = 0 ;
28729 PyObject * obj3 = 0 ;
28730 char *kwnames[] = {
28731 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28732 };
28733
28734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(1)) SWIG_fail;
28737 {
28738 arg2 = (int)(SWIG_As_int(obj1));
28739 if (SWIG_arg_fail(2)) SWIG_fail;
28740 }
28741 {
28742 arg3 = (int)(SWIG_As_int(obj2));
28743 if (SWIG_arg_fail(3)) SWIG_fail;
28744 }
28745 {
28746 arg4 = (int)(SWIG_As_int(obj3));
28747 if (SWIG_arg_fail(4)) SWIG_fail;
28748 }
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj;
28767 wxWindow *arg1 = (wxWindow *) 0 ;
28768 int arg2 ;
28769 bool result;
28770 PyObject * obj0 = 0 ;
28771 PyObject * obj1 = 0 ;
28772 char *kwnames[] = {
28773 (char *) "self",(char *) "hotkeyId", NULL
28774 };
28775
28776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(1)) SWIG_fail;
28779 {
28780 arg2 = (int)(SWIG_As_int(obj1));
28781 if (SWIG_arg_fail(2)) SWIG_fail;
28782 }
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28786
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 {
28791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28792 }
28793 return resultobj;
28794 fail:
28795 return NULL;
28796 }
28797
28798
28799 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28800 PyObject *resultobj;
28801 wxWindow *arg1 = (wxWindow *) 0 ;
28802 wxPoint *arg2 = 0 ;
28803 wxPoint result;
28804 wxPoint temp2 ;
28805 PyObject * obj0 = 0 ;
28806 PyObject * obj1 = 0 ;
28807 char *kwnames[] = {
28808 (char *) "self",(char *) "pt", NULL
28809 };
28810
28811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28813 if (SWIG_arg_fail(1)) SWIG_fail;
28814 {
28815 arg2 = &temp2;
28816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28817 }
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28821
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 {
28826 wxPoint * resultptr;
28827 resultptr = new wxPoint((wxPoint &)(result));
28828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28829 }
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj;
28838 wxWindow *arg1 = (wxWindow *) 0 ;
28839 wxSize *arg2 = 0 ;
28840 wxSize result;
28841 wxSize temp2 ;
28842 PyObject * obj0 = 0 ;
28843 PyObject * obj1 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self",(char *) "sz", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 {
28852 arg2 = &temp2;
28853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28854 }
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 {
28863 wxSize * resultptr;
28864 resultptr = new wxSize((wxSize &)(result));
28865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28866 }
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28874 PyObject *resultobj;
28875 wxWindow *arg1 = (wxWindow *) 0 ;
28876 wxPoint *arg2 = 0 ;
28877 wxPoint result;
28878 wxPoint temp2 ;
28879 PyObject * obj0 = 0 ;
28880 PyObject * obj1 = 0 ;
28881 char *kwnames[] = {
28882 (char *) "self",(char *) "pt", NULL
28883 };
28884
28885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28887 if (SWIG_arg_fail(1)) SWIG_fail;
28888 {
28889 arg2 = &temp2;
28890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28891 }
28892 {
28893 PyThreadState* __tstate = wxPyBeginAllowThreads();
28894 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28895
28896 wxPyEndAllowThreads(__tstate);
28897 if (PyErr_Occurred()) SWIG_fail;
28898 }
28899 {
28900 wxPoint * resultptr;
28901 resultptr = new wxPoint((wxPoint &)(result));
28902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28903 }
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj;
28912 wxWindow *arg1 = (wxWindow *) 0 ;
28913 wxSize *arg2 = 0 ;
28914 wxSize result;
28915 wxSize temp2 ;
28916 PyObject * obj0 = 0 ;
28917 PyObject * obj1 = 0 ;
28918 char *kwnames[] = {
28919 (char *) "self",(char *) "sz", NULL
28920 };
28921
28922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28924 if (SWIG_arg_fail(1)) SWIG_fail;
28925 {
28926 arg2 = &temp2;
28927 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28928 }
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 {
28937 wxSize * resultptr;
28938 resultptr = new wxSize((wxSize &)(result));
28939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28940 }
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj;
28949 wxWindow *arg1 = (wxWindow *) 0 ;
28950 wxPoint *arg2 = 0 ;
28951 wxPoint result;
28952 wxPoint temp2 ;
28953 PyObject * obj0 = 0 ;
28954 PyObject * obj1 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self",(char *) "pt", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 arg2 = &temp2;
28964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28965 }
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28969
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 {
28974 wxPoint * resultptr;
28975 resultptr = new wxPoint((wxPoint &)(result));
28976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28977 }
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj;
28986 wxWindow *arg1 = (wxWindow *) 0 ;
28987 wxSize *arg2 = 0 ;
28988 wxSize result;
28989 wxSize temp2 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28992 char *kwnames[] = {
28993 (char *) "self",(char *) "sz", NULL
28994 };
28995
28996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",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 {
29000 arg2 = &temp2;
29001 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 {
29011 wxSize * resultptr;
29012 resultptr = new wxSize((wxSize &)(result));
29013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29014 }
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj;
29023 wxWindow *arg1 = (wxWindow *) 0 ;
29024 int arg2 ;
29025 int arg3 ;
29026 PyObject * obj0 = 0 ;
29027 PyObject * obj1 = 0 ;
29028 PyObject * obj2 = 0 ;
29029 char *kwnames[] = {
29030 (char *) "self",(char *) "x",(char *) "y", NULL
29031 };
29032
29033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29035 if (SWIG_arg_fail(1)) SWIG_fail;
29036 {
29037 arg2 = (int)(SWIG_As_int(obj1));
29038 if (SWIG_arg_fail(2)) SWIG_fail;
29039 }
29040 {
29041 arg3 = (int)(SWIG_As_int(obj2));
29042 if (SWIG_arg_fail(3)) SWIG_fail;
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->WarpPointer(arg2,arg3);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 Py_INCREF(Py_None); resultobj = Py_None;
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29059 PyObject *resultobj;
29060 wxWindow *arg1 = (wxWindow *) 0 ;
29061 PyObject * obj0 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 (arg1)->CaptureMouse();
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 Py_INCREF(Py_None); resultobj = Py_None;
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29084 PyObject *resultobj;
29085 wxWindow *arg1 = (wxWindow *) 0 ;
29086 PyObject * obj0 = 0 ;
29087 char *kwnames[] = {
29088 (char *) "self", NULL
29089 };
29090
29091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) 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 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 (arg1)->ReleaseMouse();
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 Py_INCREF(Py_None); resultobj = Py_None;
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxWindow *result;
29111 char *kwnames[] = {
29112 NULL
29113 };
29114
29115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29116 {
29117 if (!wxPyCheckForApp()) SWIG_fail;
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 result = (wxWindow *)wxWindow::GetCapture();
29120
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 {
29125 resultobj = wxPyMake_wxObject(result, 0);
29126 }
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxWindow *arg1 = (wxWindow *) 0 ;
29136 bool result;
29137 PyObject * obj0 = 0 ;
29138 char *kwnames[] = {
29139 (char *) "self", NULL
29140 };
29141
29142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29144 if (SWIG_arg_fail(1)) SWIG_fail;
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 result = (bool)((wxWindow const *)arg1)->HasCapture();
29148
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 {
29153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29154 }
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj;
29163 wxWindow *arg1 = (wxWindow *) 0 ;
29164 bool arg2 = (bool) true ;
29165 wxRect *arg3 = (wxRect *) NULL ;
29166 PyObject * obj0 = 0 ;
29167 PyObject * obj1 = 0 ;
29168 PyObject * obj2 = 0 ;
29169 char *kwnames[] = {
29170 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29171 };
29172
29173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29175 if (SWIG_arg_fail(1)) SWIG_fail;
29176 if (obj1) {
29177 {
29178 arg2 = (bool)(SWIG_As_bool(obj1));
29179 if (SWIG_arg_fail(2)) SWIG_fail;
29180 }
29181 }
29182 if (obj2) {
29183 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29184 if (SWIG_arg_fail(3)) SWIG_fail;
29185 }
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29189
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 Py_INCREF(Py_None); resultobj = Py_None;
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29201 PyObject *resultobj;
29202 wxWindow *arg1 = (wxWindow *) 0 ;
29203 wxRect *arg2 = 0 ;
29204 bool arg3 = (bool) true ;
29205 wxRect temp2 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 PyObject * obj2 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29215 if (SWIG_arg_fail(1)) SWIG_fail;
29216 {
29217 arg2 = &temp2;
29218 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29219 }
29220 if (obj2) {
29221 {
29222 arg3 = (bool)(SWIG_As_bool(obj2));
29223 if (SWIG_arg_fail(3)) SWIG_fail;
29224 }
29225 }
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29229
29230 wxPyEndAllowThreads(__tstate);
29231 if (PyErr_Occurred()) SWIG_fail;
29232 }
29233 Py_INCREF(Py_None); resultobj = Py_None;
29234 return resultobj;
29235 fail:
29236 return NULL;
29237 }
29238
29239
29240 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29241 PyObject *resultobj;
29242 wxWindow *arg1 = (wxWindow *) 0 ;
29243 PyObject * obj0 = 0 ;
29244 char *kwnames[] = {
29245 (char *) "self", NULL
29246 };
29247
29248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29250 if (SWIG_arg_fail(1)) SWIG_fail;
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 (arg1)->Update();
29254
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 Py_INCREF(Py_None); resultobj = Py_None;
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29266 PyObject *resultobj;
29267 wxWindow *arg1 = (wxWindow *) 0 ;
29268 PyObject * obj0 = 0 ;
29269 char *kwnames[] = {
29270 (char *) "self", NULL
29271 };
29272
29273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29275 if (SWIG_arg_fail(1)) SWIG_fail;
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 (arg1)->ClearBackground();
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 Py_INCREF(Py_None); resultobj = Py_None;
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxWindow *arg1 = (wxWindow *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 (arg1)->Freeze();
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 Py_INCREF(Py_None); resultobj = Py_None;
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj;
29317 wxWindow *arg1 = (wxWindow *) 0 ;
29318 PyObject * obj0 = 0 ;
29319 char *kwnames[] = {
29320 (char *) "self", NULL
29321 };
29322
29323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29325 if (SWIG_arg_fail(1)) SWIG_fail;
29326 {
29327 PyThreadState* __tstate = wxPyBeginAllowThreads();
29328 (arg1)->Thaw();
29329
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 Py_INCREF(Py_None); resultobj = Py_None;
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj;
29342 wxWindow *arg1 = (wxWindow *) 0 ;
29343 wxDC *arg2 = 0 ;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 char *kwnames[] = {
29347 (char *) "self",(char *) "dc", NULL
29348 };
29349
29350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29352 if (SWIG_arg_fail(1)) SWIG_fail;
29353 {
29354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(2)) SWIG_fail;
29356 if (arg2 == NULL) {
29357 SWIG_null_ref("wxDC");
29358 }
29359 if (SWIG_arg_fail(2)) SWIG_fail;
29360 }
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 (arg1)->PrepareDC(*arg2);
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 Py_INCREF(Py_None); resultobj = Py_None;
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj;
29377 wxWindow *arg1 = (wxWindow *) 0 ;
29378 wxRegion *result;
29379 PyObject * obj0 = 0 ;
29380 char *kwnames[] = {
29381 (char *) "self", NULL
29382 };
29383
29384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29386 if (SWIG_arg_fail(1)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 {
29390 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29391 result = (wxRegion *) &_result_ref;
29392 }
29393
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj;
29406 wxWindow *arg1 = (wxWindow *) 0 ;
29407 wxRect result;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 {
29424 wxRect * resultptr;
29425 resultptr = new wxRect((wxRect &)(result));
29426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29427 }
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj;
29436 wxWindow *arg1 = (wxWindow *) 0 ;
29437 int arg2 ;
29438 int arg3 ;
29439 int arg4 = (int) 1 ;
29440 int arg5 = (int) 1 ;
29441 bool result;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 PyObject * obj2 = 0 ;
29445 PyObject * obj3 = 0 ;
29446 PyObject * obj4 = 0 ;
29447 char *kwnames[] = {
29448 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29449 };
29450
29451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29453 if (SWIG_arg_fail(1)) SWIG_fail;
29454 {
29455 arg2 = (int)(SWIG_As_int(obj1));
29456 if (SWIG_arg_fail(2)) SWIG_fail;
29457 }
29458 {
29459 arg3 = (int)(SWIG_As_int(obj2));
29460 if (SWIG_arg_fail(3)) SWIG_fail;
29461 }
29462 if (obj3) {
29463 {
29464 arg4 = (int)(SWIG_As_int(obj3));
29465 if (SWIG_arg_fail(4)) SWIG_fail;
29466 }
29467 }
29468 if (obj4) {
29469 {
29470 arg5 = (int)(SWIG_As_int(obj4));
29471 if (SWIG_arg_fail(5)) SWIG_fail;
29472 }
29473 }
29474 {
29475 PyThreadState* __tstate = wxPyBeginAllowThreads();
29476 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29477
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 {
29482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29483 }
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj;
29492 wxWindow *arg1 = (wxWindow *) 0 ;
29493 wxPoint *arg2 = 0 ;
29494 bool result;
29495 wxPoint temp2 ;
29496 PyObject * obj0 = 0 ;
29497 PyObject * obj1 = 0 ;
29498 char *kwnames[] = {
29499 (char *) "self",(char *) "pt", NULL
29500 };
29501
29502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29504 if (SWIG_arg_fail(1)) SWIG_fail;
29505 {
29506 arg2 = &temp2;
29507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29508 }
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29512
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 {
29517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29518 }
29519 return resultobj;
29520 fail:
29521 return NULL;
29522 }
29523
29524
29525 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29526 PyObject *resultobj;
29527 wxWindow *arg1 = (wxWindow *) 0 ;
29528 wxRect *arg2 = 0 ;
29529 bool result;
29530 wxRect temp2 ;
29531 PyObject * obj0 = 0 ;
29532 PyObject * obj1 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self",(char *) "rect", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 arg2 = &temp2;
29542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29543 }
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29547
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 {
29552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29553 }
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj;
29562 wxWindow *arg1 = (wxWindow *) 0 ;
29563 wxVisualAttributes result;
29564 PyObject * obj0 = 0 ;
29565 char *kwnames[] = {
29566 (char *) "self", NULL
29567 };
29568
29569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29571 if (SWIG_arg_fail(1)) SWIG_fail;
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29575
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 wxVisualAttributes * resultptr;
29581 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29583 }
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29591 PyObject *resultobj;
29592 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29593 wxVisualAttributes result;
29594 PyObject * obj0 = 0 ;
29595 char *kwnames[] = {
29596 (char *) "variant", NULL
29597 };
29598
29599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29600 if (obj0) {
29601 {
29602 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29603 if (SWIG_arg_fail(1)) SWIG_fail;
29604 }
29605 }
29606 {
29607 if (!wxPyCheckForApp()) SWIG_fail;
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29610
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 wxVisualAttributes * resultptr;
29616 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29618 }
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj;
29627 wxWindow *arg1 = (wxWindow *) 0 ;
29628 wxColour *arg2 = 0 ;
29629 bool result;
29630 wxColour temp2 ;
29631 PyObject * obj0 = 0 ;
29632 PyObject * obj1 = 0 ;
29633 char *kwnames[] = {
29634 (char *) "self",(char *) "colour", NULL
29635 };
29636
29637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29639 if (SWIG_arg_fail(1)) SWIG_fail;
29640 {
29641 arg2 = &temp2;
29642 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29643 }
29644 {
29645 PyThreadState* __tstate = wxPyBeginAllowThreads();
29646 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29647
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 {
29652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29653 }
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj;
29662 wxWindow *arg1 = (wxWindow *) 0 ;
29663 wxColour *arg2 = 0 ;
29664 wxColour temp2 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char *kwnames[] = {
29668 (char *) "self",(char *) "colour", NULL
29669 };
29670
29671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29673 if (SWIG_arg_fail(1)) SWIG_fail;
29674 {
29675 arg2 = &temp2;
29676 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 Py_INCREF(Py_None); resultobj = Py_None;
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxWindow *arg1 = (wxWindow *) 0 ;
29695 wxColour *arg2 = 0 ;
29696 bool result;
29697 wxColour temp2 ;
29698 PyObject * obj0 = 0 ;
29699 PyObject * obj1 = 0 ;
29700 char *kwnames[] = {
29701 (char *) "self",(char *) "colour", NULL
29702 };
29703
29704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29706 if (SWIG_arg_fail(1)) SWIG_fail;
29707 {
29708 arg2 = &temp2;
29709 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29710 }
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29728 PyObject *resultobj;
29729 wxWindow *arg1 = (wxWindow *) 0 ;
29730 wxColour *arg2 = 0 ;
29731 wxColour temp2 ;
29732 PyObject * obj0 = 0 ;
29733 PyObject * obj1 = 0 ;
29734 char *kwnames[] = {
29735 (char *) "self",(char *) "colour", NULL
29736 };
29737
29738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29740 if (SWIG_arg_fail(1)) SWIG_fail;
29741 {
29742 arg2 = &temp2;
29743 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29744 }
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29748
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 Py_INCREF(Py_None); resultobj = Py_None;
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj;
29761 wxWindow *arg1 = (wxWindow *) 0 ;
29762 wxColour result;
29763 PyObject * obj0 = 0 ;
29764 char *kwnames[] = {
29765 (char *) "self", NULL
29766 };
29767
29768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",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 = ((wxWindow const *)arg1)->GetBackgroundColour();
29774
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 wxColour * resultptr;
29780 resultptr = new wxColour((wxColour &)(result));
29781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29782 }
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29790 PyObject *resultobj;
29791 wxWindow *arg1 = (wxWindow *) 0 ;
29792 wxColour result;
29793 PyObject * obj0 = 0 ;
29794 char *kwnames[] = {
29795 (char *) "self", NULL
29796 };
29797
29798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29800 if (SWIG_arg_fail(1)) SWIG_fail;
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = ((wxWindow const *)arg1)->GetForegroundColour();
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 wxColour * resultptr;
29810 resultptr = new wxColour((wxColour &)(result));
29811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj;
29821 wxWindow *arg1 = (wxWindow *) 0 ;
29822 bool result;
29823 PyObject * obj0 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29834
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 {
29839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29840 }
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29848 PyObject *resultobj;
29849 wxWindow *arg1 = (wxWindow *) 0 ;
29850 bool result;
29851 PyObject * obj0 = 0 ;
29852 char *kwnames[] = {
29853 (char *) "self", NULL
29854 };
29855
29856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29858 if (SWIG_arg_fail(1)) SWIG_fail;
29859 {
29860 PyThreadState* __tstate = wxPyBeginAllowThreads();
29861 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29862
29863 wxPyEndAllowThreads(__tstate);
29864 if (PyErr_Occurred()) SWIG_fail;
29865 }
29866 {
29867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 wxBackgroundStyle arg2 ;
29879 bool result;
29880 PyObject * obj0 = 0 ;
29881 PyObject * obj1 = 0 ;
29882 char *kwnames[] = {
29883 (char *) "self",(char *) "style", NULL
29884 };
29885
29886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29888 if (SWIG_arg_fail(1)) SWIG_fail;
29889 {
29890 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29891 if (SWIG_arg_fail(2)) SWIG_fail;
29892 }
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29896
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 {
29901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29902 }
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 wxBackgroundStyle result;
29913 PyObject * obj0 = 0 ;
29914 char *kwnames[] = {
29915 (char *) "self", NULL
29916 };
29917
29918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29920 if (SWIG_arg_fail(1)) SWIG_fail;
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 resultobj = SWIG_From_int((result));
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj;
29937 wxWindow *arg1 = (wxWindow *) 0 ;
29938 bool result;
29939 PyObject * obj0 = 0 ;
29940 char *kwnames[] = {
29941 (char *) "self", NULL
29942 };
29943
29944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29946 if (SWIG_arg_fail(1)) SWIG_fail;
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 result = (bool)(arg1)->HasTransparentBackground();
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29956 }
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29964 PyObject *resultobj;
29965 wxWindow *arg1 = (wxWindow *) 0 ;
29966 wxCursor *arg2 = 0 ;
29967 bool result;
29968 PyObject * obj0 = 0 ;
29969 PyObject * obj1 = 0 ;
29970 char *kwnames[] = {
29971 (char *) "self",(char *) "cursor", NULL
29972 };
29973
29974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29976 if (SWIG_arg_fail(1)) SWIG_fail;
29977 {
29978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29979 if (SWIG_arg_fail(2)) SWIG_fail;
29980 if (arg2 == NULL) {
29981 SWIG_null_ref("wxCursor");
29982 }
29983 if (SWIG_arg_fail(2)) SWIG_fail;
29984 }
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29988
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 {
29993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29994 }
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30002 PyObject *resultobj;
30003 wxWindow *arg1 = (wxWindow *) 0 ;
30004 wxCursor result;
30005 PyObject * obj0 = 0 ;
30006 char *kwnames[] = {
30007 (char *) "self", NULL
30008 };
30009
30010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",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 result = (arg1)->GetCursor();
30016
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 wxCursor * resultptr;
30022 resultptr = new wxCursor((wxCursor &)(result));
30023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxWindow *arg1 = (wxWindow *) 0 ;
30034 wxFont *arg2 = 0 ;
30035 bool result;
30036 PyObject * obj0 = 0 ;
30037 PyObject * obj1 = 0 ;
30038 char *kwnames[] = {
30039 (char *) "self",(char *) "font", NULL
30040 };
30041
30042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(1)) SWIG_fail;
30045 {
30046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30047 if (SWIG_arg_fail(2)) SWIG_fail;
30048 if (arg2 == NULL) {
30049 SWIG_null_ref("wxFont");
30050 }
30051 if (SWIG_arg_fail(2)) SWIG_fail;
30052 }
30053 {
30054 PyThreadState* __tstate = wxPyBeginAllowThreads();
30055 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30056
30057 wxPyEndAllowThreads(__tstate);
30058 if (PyErr_Occurred()) SWIG_fail;
30059 }
30060 {
30061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30062 }
30063 return resultobj;
30064 fail:
30065 return NULL;
30066 }
30067
30068
30069 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30070 PyObject *resultobj;
30071 wxWindow *arg1 = (wxWindow *) 0 ;
30072 wxFont *arg2 = 0 ;
30073 PyObject * obj0 = 0 ;
30074 PyObject * obj1 = 0 ;
30075 char *kwnames[] = {
30076 (char *) "self",(char *) "font", NULL
30077 };
30078
30079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30081 if (SWIG_arg_fail(1)) SWIG_fail;
30082 {
30083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30084 if (SWIG_arg_fail(2)) SWIG_fail;
30085 if (arg2 == NULL) {
30086 SWIG_null_ref("wxFont");
30087 }
30088 if (SWIG_arg_fail(2)) SWIG_fail;
30089 }
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 (arg1)->SetOwnFont((wxFont const &)*arg2);
30093
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 Py_INCREF(Py_None); resultobj = Py_None;
30098 return resultobj;
30099 fail:
30100 return NULL;
30101 }
30102
30103
30104 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30105 PyObject *resultobj;
30106 wxWindow *arg1 = (wxWindow *) 0 ;
30107 wxFont result;
30108 PyObject * obj0 = 0 ;
30109 char *kwnames[] = {
30110 (char *) "self", NULL
30111 };
30112
30113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30115 if (SWIG_arg_fail(1)) SWIG_fail;
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 result = (arg1)->GetFont();
30119
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 {
30124 wxFont * resultptr;
30125 resultptr = new wxFont((wxFont &)(result));
30126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30127 }
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj;
30136 wxWindow *arg1 = (wxWindow *) 0 ;
30137 wxCaret *arg2 = (wxCaret *) 0 ;
30138 PyObject * obj0 = 0 ;
30139 PyObject * obj1 = 0 ;
30140 char *kwnames[] = {
30141 (char *) "self",(char *) "caret", NULL
30142 };
30143
30144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(1)) SWIG_fail;
30147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30148 if (SWIG_arg_fail(2)) SWIG_fail;
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 (arg1)->SetCaret(arg2);
30152
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 Py_INCREF(Py_None); resultobj = Py_None;
30157 return resultobj;
30158 fail:
30159 return NULL;
30160 }
30161
30162
30163 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30164 PyObject *resultobj;
30165 wxWindow *arg1 = (wxWindow *) 0 ;
30166 wxCaret *result;
30167 PyObject * obj0 = 0 ;
30168 char *kwnames[] = {
30169 (char *) "self", NULL
30170 };
30171
30172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(1)) SWIG_fail;
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj;
30191 wxWindow *arg1 = (wxWindow *) 0 ;
30192 int result;
30193 PyObject * obj0 = 0 ;
30194 char *kwnames[] = {
30195 (char *) "self", NULL
30196 };
30197
30198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30200 if (SWIG_arg_fail(1)) SWIG_fail;
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30204
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 {
30209 resultobj = SWIG_From_int((int)(result));
30210 }
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 int result;
30221 PyObject * obj0 = 0 ;
30222 char *kwnames[] = {
30223 (char *) "self", NULL
30224 };
30225
30226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30228 if (SWIG_arg_fail(1)) SWIG_fail;
30229 {
30230 PyThreadState* __tstate = wxPyBeginAllowThreads();
30231 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30232
30233 wxPyEndAllowThreads(__tstate);
30234 if (PyErr_Occurred()) SWIG_fail;
30235 }
30236 {
30237 resultobj = SWIG_From_int((int)(result));
30238 }
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj;
30247 wxWindow *arg1 = (wxWindow *) 0 ;
30248 wxString *arg2 = 0 ;
30249 int *arg3 = (int *) 0 ;
30250 int *arg4 = (int *) 0 ;
30251 bool temp2 = false ;
30252 int temp3 ;
30253 int res3 = 0 ;
30254 int temp4 ;
30255 int res4 = 0 ;
30256 PyObject * obj0 = 0 ;
30257 PyObject * obj1 = 0 ;
30258 char *kwnames[] = {
30259 (char *) "self",(char *) "string", NULL
30260 };
30261
30262 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30263 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30266 if (SWIG_arg_fail(1)) SWIG_fail;
30267 {
30268 arg2 = wxString_in_helper(obj1);
30269 if (arg2 == NULL) SWIG_fail;
30270 temp2 = true;
30271 }
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30275
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 Py_INCREF(Py_None); resultobj = Py_None;
30280 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30281 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30282 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30283 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30284 {
30285 if (temp2)
30286 delete arg2;
30287 }
30288 return resultobj;
30289 fail:
30290 {
30291 if (temp2)
30292 delete arg2;
30293 }
30294 return NULL;
30295 }
30296
30297
30298 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj;
30300 wxWindow *arg1 = (wxWindow *) 0 ;
30301 wxString *arg2 = 0 ;
30302 int *arg3 = (int *) 0 ;
30303 int *arg4 = (int *) 0 ;
30304 int *arg5 = (int *) 0 ;
30305 int *arg6 = (int *) 0 ;
30306 wxFont *arg7 = (wxFont *) NULL ;
30307 bool temp2 = false ;
30308 int temp3 ;
30309 int res3 = 0 ;
30310 int temp4 ;
30311 int res4 = 0 ;
30312 int temp5 ;
30313 int res5 = 0 ;
30314 int temp6 ;
30315 int res6 = 0 ;
30316 PyObject * obj0 = 0 ;
30317 PyObject * obj1 = 0 ;
30318 PyObject * obj2 = 0 ;
30319 char *kwnames[] = {
30320 (char *) "self",(char *) "string",(char *) "font", NULL
30321 };
30322
30323 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30324 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30325 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30326 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30329 if (SWIG_arg_fail(1)) SWIG_fail;
30330 {
30331 arg2 = wxString_in_helper(obj1);
30332 if (arg2 == NULL) SWIG_fail;
30333 temp2 = true;
30334 }
30335 if (obj2) {
30336 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30337 if (SWIG_arg_fail(7)) SWIG_fail;
30338 }
30339 {
30340 PyThreadState* __tstate = wxPyBeginAllowThreads();
30341 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30342
30343 wxPyEndAllowThreads(__tstate);
30344 if (PyErr_Occurred()) SWIG_fail;
30345 }
30346 Py_INCREF(Py_None); resultobj = Py_None;
30347 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30348 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30349 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30350 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30351 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30352 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30353 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30354 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30355 {
30356 if (temp2)
30357 delete arg2;
30358 }
30359 return resultobj;
30360 fail:
30361 {
30362 if (temp2)
30363 delete arg2;
30364 }
30365 return NULL;
30366 }
30367
30368
30369 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30370 PyObject *resultobj;
30371 wxWindow *arg1 = (wxWindow *) 0 ;
30372 int *arg2 = (int *) 0 ;
30373 int *arg3 = (int *) 0 ;
30374 int temp2 ;
30375 int res2 = 0 ;
30376 int temp3 ;
30377 int res3 = 0 ;
30378 PyObject * obj0 = 0 ;
30379 PyObject * obj1 = 0 ;
30380 PyObject * obj2 = 0 ;
30381 char *kwnames[] = {
30382 (char *) "self",(char *) "x",(char *) "y", NULL
30383 };
30384
30385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30387 if (SWIG_arg_fail(1)) SWIG_fail;
30388 {
30389 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30390 temp2 = SWIG_As_int(obj1);
30391 if (SWIG_arg_fail(2)) SWIG_fail;
30392 arg2 = &temp2;
30393 res2 = SWIG_NEWOBJ;
30394 }
30395 }
30396 {
30397 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30398 temp3 = SWIG_As_int(obj2);
30399 if (SWIG_arg_fail(3)) SWIG_fail;
30400 arg3 = &temp3;
30401 res3 = SWIG_NEWOBJ;
30402 }
30403 }
30404 {
30405 PyThreadState* __tstate = wxPyBeginAllowThreads();
30406 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30407
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 Py_INCREF(Py_None); resultobj = Py_None;
30412 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30413 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30414 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30415 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30416 return resultobj;
30417 fail:
30418 return NULL;
30419 }
30420
30421
30422 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30423 PyObject *resultobj;
30424 wxWindow *arg1 = (wxWindow *) 0 ;
30425 int *arg2 = (int *) 0 ;
30426 int *arg3 = (int *) 0 ;
30427 int temp2 ;
30428 int res2 = 0 ;
30429 int temp3 ;
30430 int res3 = 0 ;
30431 PyObject * obj0 = 0 ;
30432 PyObject * obj1 = 0 ;
30433 PyObject * obj2 = 0 ;
30434 char *kwnames[] = {
30435 (char *) "self",(char *) "x",(char *) "y", NULL
30436 };
30437
30438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(1)) SWIG_fail;
30441 {
30442 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30443 temp2 = SWIG_As_int(obj1);
30444 if (SWIG_arg_fail(2)) SWIG_fail;
30445 arg2 = &temp2;
30446 res2 = SWIG_NEWOBJ;
30447 }
30448 }
30449 {
30450 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30451 temp3 = SWIG_As_int(obj2);
30452 if (SWIG_arg_fail(3)) SWIG_fail;
30453 arg3 = &temp3;
30454 res3 = SWIG_NEWOBJ;
30455 }
30456 }
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30460
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 Py_INCREF(Py_None); resultobj = Py_None;
30465 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30466 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30467 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30468 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30469 return resultobj;
30470 fail:
30471 return NULL;
30472 }
30473
30474
30475 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30476 PyObject *resultobj;
30477 wxWindow *arg1 = (wxWindow *) 0 ;
30478 wxPoint *arg2 = 0 ;
30479 wxPoint result;
30480 wxPoint temp2 ;
30481 PyObject * obj0 = 0 ;
30482 PyObject * obj1 = 0 ;
30483 char *kwnames[] = {
30484 (char *) "self",(char *) "pt", NULL
30485 };
30486
30487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30489 if (SWIG_arg_fail(1)) SWIG_fail;
30490 {
30491 arg2 = &temp2;
30492 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30493 }
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30497
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 {
30502 wxPoint * resultptr;
30503 resultptr = new wxPoint((wxPoint &)(result));
30504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30505 }
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 wxPoint *arg2 = 0 ;
30516 wxPoint result;
30517 wxPoint temp2 ;
30518 PyObject * obj0 = 0 ;
30519 PyObject * obj1 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self",(char *) "pt", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 arg2 = &temp2;
30529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30530 }
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30534
30535 wxPyEndAllowThreads(__tstate);
30536 if (PyErr_Occurred()) SWIG_fail;
30537 }
30538 {
30539 wxPoint * resultptr;
30540 resultptr = new wxPoint((wxPoint &)(result));
30541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 int arg2 ;
30553 int arg3 ;
30554 wxHitTest result;
30555 PyObject * obj0 = 0 ;
30556 PyObject * obj1 = 0 ;
30557 PyObject * obj2 = 0 ;
30558 char *kwnames[] = {
30559 (char *) "self",(char *) "x",(char *) "y", NULL
30560 };
30561
30562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(1)) SWIG_fail;
30565 {
30566 arg2 = (int)(SWIG_As_int(obj1));
30567 if (SWIG_arg_fail(2)) SWIG_fail;
30568 }
30569 {
30570 arg3 = (int)(SWIG_As_int(obj2));
30571 if (SWIG_arg_fail(3)) SWIG_fail;
30572 }
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30576
30577 wxPyEndAllowThreads(__tstate);
30578 if (PyErr_Occurred()) SWIG_fail;
30579 }
30580 resultobj = SWIG_From_int((result));
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30588 PyObject *resultobj;
30589 wxWindow *arg1 = (wxWindow *) 0 ;
30590 wxPoint *arg2 = 0 ;
30591 wxHitTest result;
30592 wxPoint temp2 ;
30593 PyObject * obj0 = 0 ;
30594 PyObject * obj1 = 0 ;
30595 char *kwnames[] = {
30596 (char *) "self",(char *) "pt", NULL
30597 };
30598
30599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30601 if (SWIG_arg_fail(1)) SWIG_fail;
30602 {
30603 arg2 = &temp2;
30604 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30605 }
30606 {
30607 PyThreadState* __tstate = wxPyBeginAllowThreads();
30608 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30609
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 resultobj = SWIG_From_int((result));
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30621 PyObject *resultobj;
30622 wxWindow *arg1 = (wxWindow *) 0 ;
30623 long arg2 ;
30624 wxBorder result;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627
30628 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 arg2 = (long)(SWIG_As_long(obj1));
30633 if (SWIG_arg_fail(2)) SWIG_fail;
30634 }
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30638
30639 wxPyEndAllowThreads(__tstate);
30640 if (PyErr_Occurred()) SWIG_fail;
30641 }
30642 resultobj = SWIG_From_int((result));
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30650 PyObject *resultobj;
30651 wxWindow *arg1 = (wxWindow *) 0 ;
30652 wxBorder result;
30653 PyObject * obj0 = 0 ;
30654
30655 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30657 if (SWIG_arg_fail(1)) SWIG_fail;
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30661
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 resultobj = SWIG_From_int((result));
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30673 int argc;
30674 PyObject *argv[3];
30675 int ii;
30676
30677 argc = PyObject_Length(args);
30678 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30679 argv[ii] = PyTuple_GetItem(args,ii);
30680 }
30681 if (argc == 1) {
30682 int _v;
30683 {
30684 void *ptr;
30685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30686 _v = 0;
30687 PyErr_Clear();
30688 } else {
30689 _v = 1;
30690 }
30691 }
30692 if (_v) {
30693 return _wrap_Window_GetBorder__SWIG_1(self,args);
30694 }
30695 }
30696 if (argc == 2) {
30697 int _v;
30698 {
30699 void *ptr;
30700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30701 _v = 0;
30702 PyErr_Clear();
30703 } else {
30704 _v = 1;
30705 }
30706 }
30707 if (_v) {
30708 _v = SWIG_Check_long(argv[1]);
30709 if (_v) {
30710 return _wrap_Window_GetBorder__SWIG_0(self,args);
30711 }
30712 }
30713 }
30714
30715 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30716 return NULL;
30717 }
30718
30719
30720 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 long arg2 = (long) wxUPDATE_UI_NONE ;
30724 PyObject * obj0 = 0 ;
30725 PyObject * obj1 = 0 ;
30726 char *kwnames[] = {
30727 (char *) "self",(char *) "flags", NULL
30728 };
30729
30730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30732 if (SWIG_arg_fail(1)) SWIG_fail;
30733 if (obj1) {
30734 {
30735 arg2 = (long)(SWIG_As_long(obj1));
30736 if (SWIG_arg_fail(2)) SWIG_fail;
30737 }
30738 }
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 (arg1)->UpdateWindowUI(arg2);
30742
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 Py_INCREF(Py_None); resultobj = Py_None;
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30754 PyObject *resultobj;
30755 wxWindow *arg1 = (wxWindow *) 0 ;
30756 wxMenu *arg2 = (wxMenu *) 0 ;
30757 int arg3 = (int) -1 ;
30758 int arg4 = (int) -1 ;
30759 bool result;
30760 PyObject * obj0 = 0 ;
30761 PyObject * obj1 = 0 ;
30762 PyObject * obj2 = 0 ;
30763 PyObject * obj3 = 0 ;
30764 char *kwnames[] = {
30765 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30766 };
30767
30768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30770 if (SWIG_arg_fail(1)) SWIG_fail;
30771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30772 if (SWIG_arg_fail(2)) SWIG_fail;
30773 if (obj2) {
30774 {
30775 arg3 = (int)(SWIG_As_int(obj2));
30776 if (SWIG_arg_fail(3)) SWIG_fail;
30777 }
30778 }
30779 if (obj3) {
30780 {
30781 arg4 = (int)(SWIG_As_int(obj3));
30782 if (SWIG_arg_fail(4)) SWIG_fail;
30783 }
30784 }
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30788
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj;
30803 wxWindow *arg1 = (wxWindow *) 0 ;
30804 wxMenu *arg2 = (wxMenu *) 0 ;
30805 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30806 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30807 bool result;
30808 wxPoint temp3 ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 PyObject * obj2 = 0 ;
30812 char *kwnames[] = {
30813 (char *) "self",(char *) "menu",(char *) "pos", NULL
30814 };
30815
30816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30818 if (SWIG_arg_fail(1)) SWIG_fail;
30819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(2)) SWIG_fail;
30821 if (obj2) {
30822 {
30823 arg3 = &temp3;
30824 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30825 }
30826 }
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 {
30835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30836 }
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30844 PyObject *resultobj;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 long result;
30847 PyObject * obj0 = 0 ;
30848 char *kwnames[] = {
30849 (char *) "self", NULL
30850 };
30851
30852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",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 = (long)wxWindow_GetHandle(arg1);
30858
30859 wxPyEndAllowThreads(__tstate);
30860 if (PyErr_Occurred()) SWIG_fail;
30861 }
30862 {
30863 resultobj = SWIG_From_long((long)(result));
30864 }
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj;
30873 wxWindow *arg1 = (wxWindow *) 0 ;
30874 long arg2 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 char *kwnames[] = {
30878 (char *) "self",(char *) "handle", NULL
30879 };
30880
30881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30883 if (SWIG_arg_fail(1)) SWIG_fail;
30884 {
30885 arg2 = (long)(SWIG_As_long(obj1));
30886 if (SWIG_arg_fail(2)) SWIG_fail;
30887 }
30888 {
30889 PyThreadState* __tstate = wxPyBeginAllowThreads();
30890 wxWindow_AssociateHandle(arg1,arg2);
30891
30892 wxPyEndAllowThreads(__tstate);
30893 if (PyErr_Occurred()) SWIG_fail;
30894 }
30895 Py_INCREF(Py_None); resultobj = Py_None;
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj;
30904 wxWindow *arg1 = (wxWindow *) 0 ;
30905 PyObject * obj0 = 0 ;
30906 char *kwnames[] = {
30907 (char *) "self", NULL
30908 };
30909
30910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30912 if (SWIG_arg_fail(1)) SWIG_fail;
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 (arg1)->DissociateHandle();
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 Py_INCREF(Py_None); resultobj = Py_None;
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 int arg2 ;
30931 bool result;
30932 PyObject * obj0 = 0 ;
30933 PyObject * obj1 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self",(char *) "orient", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 {
30942 arg2 = (int)(SWIG_As_int(obj1));
30943 if (SWIG_arg_fail(2)) SWIG_fail;
30944 }
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30948
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 {
30953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30954 }
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30962 PyObject *resultobj;
30963 wxWindow *arg1 = (wxWindow *) 0 ;
30964 int arg2 ;
30965 int arg3 ;
30966 int arg4 ;
30967 int arg5 ;
30968 bool arg6 = (bool) true ;
30969 PyObject * obj0 = 0 ;
30970 PyObject * obj1 = 0 ;
30971 PyObject * obj2 = 0 ;
30972 PyObject * obj3 = 0 ;
30973 PyObject * obj4 = 0 ;
30974 PyObject * obj5 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 arg2 = (int)(SWIG_As_int(obj1));
30984 if (SWIG_arg_fail(2)) SWIG_fail;
30985 }
30986 {
30987 arg3 = (int)(SWIG_As_int(obj2));
30988 if (SWIG_arg_fail(3)) SWIG_fail;
30989 }
30990 {
30991 arg4 = (int)(SWIG_As_int(obj3));
30992 if (SWIG_arg_fail(4)) SWIG_fail;
30993 }
30994 {
30995 arg5 = (int)(SWIG_As_int(obj4));
30996 if (SWIG_arg_fail(5)) SWIG_fail;
30997 }
30998 if (obj5) {
30999 {
31000 arg6 = (bool)(SWIG_As_bool(obj5));
31001 if (SWIG_arg_fail(6)) SWIG_fail;
31002 }
31003 }
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 Py_INCREF(Py_None); resultobj = Py_None;
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31019 PyObject *resultobj;
31020 wxWindow *arg1 = (wxWindow *) 0 ;
31021 int arg2 ;
31022 int arg3 ;
31023 bool arg4 = (bool) true ;
31024 PyObject * obj0 = 0 ;
31025 PyObject * obj1 = 0 ;
31026 PyObject * obj2 = 0 ;
31027 PyObject * obj3 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 arg2 = (int)(SWIG_As_int(obj1));
31037 if (SWIG_arg_fail(2)) SWIG_fail;
31038 }
31039 {
31040 arg3 = (int)(SWIG_As_int(obj2));
31041 if (SWIG_arg_fail(3)) SWIG_fail;
31042 }
31043 if (obj3) {
31044 {
31045 arg4 = (bool)(SWIG_As_bool(obj3));
31046 if (SWIG_arg_fail(4)) SWIG_fail;
31047 }
31048 }
31049 {
31050 PyThreadState* __tstate = wxPyBeginAllowThreads();
31051 (arg1)->SetScrollPos(arg2,arg3,arg4);
31052
31053 wxPyEndAllowThreads(__tstate);
31054 if (PyErr_Occurred()) SWIG_fail;
31055 }
31056 Py_INCREF(Py_None); resultobj = Py_None;
31057 return resultobj;
31058 fail:
31059 return NULL;
31060 }
31061
31062
31063 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31064 PyObject *resultobj;
31065 wxWindow *arg1 = (wxWindow *) 0 ;
31066 int arg2 ;
31067 int result;
31068 PyObject * obj0 = 0 ;
31069 PyObject * obj1 = 0 ;
31070 char *kwnames[] = {
31071 (char *) "self",(char *) "orientation", NULL
31072 };
31073
31074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31076 if (SWIG_arg_fail(1)) SWIG_fail;
31077 {
31078 arg2 = (int)(SWIG_As_int(obj1));
31079 if (SWIG_arg_fail(2)) SWIG_fail;
31080 }
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31084
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 {
31089 resultobj = SWIG_From_int((int)(result));
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 int arg2 ;
31101 int result;
31102 PyObject * obj0 = 0 ;
31103 PyObject * obj1 = 0 ;
31104 char *kwnames[] = {
31105 (char *) "self",(char *) "orientation", NULL
31106 };
31107
31108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31110 if (SWIG_arg_fail(1)) SWIG_fail;
31111 {
31112 arg2 = (int)(SWIG_As_int(obj1));
31113 if (SWIG_arg_fail(2)) SWIG_fail;
31114 }
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 {
31123 resultobj = SWIG_From_int((int)(result));
31124 }
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31132 PyObject *resultobj;
31133 wxWindow *arg1 = (wxWindow *) 0 ;
31134 int arg2 ;
31135 int result;
31136 PyObject * obj0 = 0 ;
31137 PyObject * obj1 = 0 ;
31138 char *kwnames[] = {
31139 (char *) "self",(char *) "orientation", NULL
31140 };
31141
31142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31144 if (SWIG_arg_fail(1)) SWIG_fail;
31145 {
31146 arg2 = (int)(SWIG_As_int(obj1));
31147 if (SWIG_arg_fail(2)) SWIG_fail;
31148 }
31149 {
31150 PyThreadState* __tstate = wxPyBeginAllowThreads();
31151 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31152
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 {
31157 resultobj = SWIG_From_int((int)(result));
31158 }
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj;
31167 wxWindow *arg1 = (wxWindow *) 0 ;
31168 int arg2 ;
31169 int arg3 ;
31170 wxRect *arg4 = (wxRect *) NULL ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 PyObject * obj2 = 0 ;
31174 PyObject * obj3 = 0 ;
31175 char *kwnames[] = {
31176 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(1)) SWIG_fail;
31182 {
31183 arg2 = (int)(SWIG_As_int(obj1));
31184 if (SWIG_arg_fail(2)) SWIG_fail;
31185 }
31186 {
31187 arg3 = (int)(SWIG_As_int(obj2));
31188 if (SWIG_arg_fail(3)) SWIG_fail;
31189 }
31190 if (obj3) {
31191 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31192 if (SWIG_arg_fail(4)) SWIG_fail;
31193 }
31194 {
31195 PyThreadState* __tstate = wxPyBeginAllowThreads();
31196 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31197
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 Py_INCREF(Py_None); resultobj = Py_None;
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 int arg2 ;
31212 bool result;
31213 PyObject * obj0 = 0 ;
31214 PyObject * obj1 = 0 ;
31215 char *kwnames[] = {
31216 (char *) "self",(char *) "lines", NULL
31217 };
31218
31219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31221 if (SWIG_arg_fail(1)) SWIG_fail;
31222 {
31223 arg2 = (int)(SWIG_As_int(obj1));
31224 if (SWIG_arg_fail(2)) SWIG_fail;
31225 }
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 result = (bool)(arg1)->ScrollLines(arg2);
31229
31230 wxPyEndAllowThreads(__tstate);
31231 if (PyErr_Occurred()) SWIG_fail;
31232 }
31233 {
31234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31235 }
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31243 PyObject *resultobj;
31244 wxWindow *arg1 = (wxWindow *) 0 ;
31245 int arg2 ;
31246 bool result;
31247 PyObject * obj0 = 0 ;
31248 PyObject * obj1 = 0 ;
31249 char *kwnames[] = {
31250 (char *) "self",(char *) "pages", NULL
31251 };
31252
31253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31255 if (SWIG_arg_fail(1)) SWIG_fail;
31256 {
31257 arg2 = (int)(SWIG_As_int(obj1));
31258 if (SWIG_arg_fail(2)) SWIG_fail;
31259 }
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = (bool)(arg1)->ScrollPages(arg2);
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 {
31268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31269 }
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 bool result;
31280 PyObject * obj0 = 0 ;
31281 char *kwnames[] = {
31282 (char *) "self", NULL
31283 };
31284
31285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31287 if (SWIG_arg_fail(1)) SWIG_fail;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (bool)(arg1)->LineUp();
31291
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 {
31296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31297 }
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj;
31306 wxWindow *arg1 = (wxWindow *) 0 ;
31307 bool result;
31308 PyObject * obj0 = 0 ;
31309 char *kwnames[] = {
31310 (char *) "self", NULL
31311 };
31312
31313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31315 if (SWIG_arg_fail(1)) SWIG_fail;
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (bool)(arg1)->LineDown();
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 bool result;
31336 PyObject * obj0 = 0 ;
31337 char *kwnames[] = {
31338 (char *) "self", NULL
31339 };
31340
31341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(1)) SWIG_fail;
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 result = (bool)(arg1)->PageUp();
31347
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 {
31352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31353 }
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31361 PyObject *resultobj;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 bool result;
31364 PyObject * obj0 = 0 ;
31365 char *kwnames[] = {
31366 (char *) "self", NULL
31367 };
31368
31369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31371 if (SWIG_arg_fail(1)) SWIG_fail;
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = (bool)(arg1)->PageDown();
31375
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 {
31380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31381 }
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31389 PyObject *resultobj;
31390 wxWindow *arg1 = (wxWindow *) 0 ;
31391 wxString *arg2 = 0 ;
31392 bool temp2 = false ;
31393 PyObject * obj0 = 0 ;
31394 PyObject * obj1 = 0 ;
31395 char *kwnames[] = {
31396 (char *) "self",(char *) "text", NULL
31397 };
31398
31399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31401 if (SWIG_arg_fail(1)) SWIG_fail;
31402 {
31403 arg2 = wxString_in_helper(obj1);
31404 if (arg2 == NULL) SWIG_fail;
31405 temp2 = true;
31406 }
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 (arg1)->SetHelpText((wxString const &)*arg2);
31410
31411 wxPyEndAllowThreads(__tstate);
31412 if (PyErr_Occurred()) SWIG_fail;
31413 }
31414 Py_INCREF(Py_None); resultobj = Py_None;
31415 {
31416 if (temp2)
31417 delete arg2;
31418 }
31419 return resultobj;
31420 fail:
31421 {
31422 if (temp2)
31423 delete arg2;
31424 }
31425 return NULL;
31426 }
31427
31428
31429 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31430 PyObject *resultobj;
31431 wxWindow *arg1 = (wxWindow *) 0 ;
31432 wxString *arg2 = 0 ;
31433 bool temp2 = false ;
31434 PyObject * obj0 = 0 ;
31435 PyObject * obj1 = 0 ;
31436 char *kwnames[] = {
31437 (char *) "self",(char *) "text", NULL
31438 };
31439
31440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31442 if (SWIG_arg_fail(1)) SWIG_fail;
31443 {
31444 arg2 = wxString_in_helper(obj1);
31445 if (arg2 == NULL) SWIG_fail;
31446 temp2 = true;
31447 }
31448 {
31449 PyThreadState* __tstate = wxPyBeginAllowThreads();
31450 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31451
31452 wxPyEndAllowThreads(__tstate);
31453 if (PyErr_Occurred()) SWIG_fail;
31454 }
31455 Py_INCREF(Py_None); resultobj = Py_None;
31456 {
31457 if (temp2)
31458 delete arg2;
31459 }
31460 return resultobj;
31461 fail:
31462 {
31463 if (temp2)
31464 delete arg2;
31465 }
31466 return NULL;
31467 }
31468
31469
31470 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31471 PyObject *resultobj;
31472 wxWindow *arg1 = (wxWindow *) 0 ;
31473 wxString result;
31474 PyObject * obj0 = 0 ;
31475 char *kwnames[] = {
31476 (char *) "self", NULL
31477 };
31478
31479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31481 if (SWIG_arg_fail(1)) SWIG_fail;
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 result = ((wxWindow const *)arg1)->GetHelpText();
31485
31486 wxPyEndAllowThreads(__tstate);
31487 if (PyErr_Occurred()) SWIG_fail;
31488 }
31489 {
31490 #if wxUSE_UNICODE
31491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31492 #else
31493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31494 #endif
31495 }
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31503 PyObject *resultobj;
31504 wxWindow *arg1 = (wxWindow *) 0 ;
31505 wxString *arg2 = 0 ;
31506 bool temp2 = false ;
31507 PyObject * obj0 = 0 ;
31508 PyObject * obj1 = 0 ;
31509 char *kwnames[] = {
31510 (char *) "self",(char *) "tip", NULL
31511 };
31512
31513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31515 if (SWIG_arg_fail(1)) SWIG_fail;
31516 {
31517 arg2 = wxString_in_helper(obj1);
31518 if (arg2 == NULL) SWIG_fail;
31519 temp2 = true;
31520 }
31521 {
31522 PyThreadState* __tstate = wxPyBeginAllowThreads();
31523 (arg1)->SetToolTip((wxString const &)*arg2);
31524
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 Py_INCREF(Py_None); resultobj = Py_None;
31529 {
31530 if (temp2)
31531 delete arg2;
31532 }
31533 return resultobj;
31534 fail:
31535 {
31536 if (temp2)
31537 delete arg2;
31538 }
31539 return NULL;
31540 }
31541
31542
31543 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 wxToolTip *arg2 = (wxToolTip *) 0 ;
31547 PyObject * obj0 = 0 ;
31548 PyObject * obj1 = 0 ;
31549 char *kwnames[] = {
31550 (char *) "self",(char *) "tip", NULL
31551 };
31552
31553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(1)) SWIG_fail;
31556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31557 if (SWIG_arg_fail(2)) SWIG_fail;
31558 {
31559 PyThreadState* __tstate = wxPyBeginAllowThreads();
31560 (arg1)->SetToolTip(arg2);
31561
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 Py_INCREF(Py_None); resultobj = Py_None;
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31573 PyObject *resultobj;
31574 wxWindow *arg1 = (wxWindow *) 0 ;
31575 wxToolTip *result;
31576 PyObject * obj0 = 0 ;
31577 char *kwnames[] = {
31578 (char *) "self", NULL
31579 };
31580
31581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31583 if (SWIG_arg_fail(1)) SWIG_fail;
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31587
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 {
31592 resultobj = wxPyMake_wxObject(result, 0);
31593 }
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj;
31602 wxWindow *arg1 = (wxWindow *) 0 ;
31603 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31604 PyObject * obj0 = 0 ;
31605 PyObject * obj1 = 0 ;
31606 char *kwnames[] = {
31607 (char *) "self",(char *) "dropTarget", NULL
31608 };
31609
31610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31612 if (SWIG_arg_fail(1)) SWIG_fail;
31613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31614 if (SWIG_arg_fail(2)) SWIG_fail;
31615 {
31616 PyThreadState* __tstate = wxPyBeginAllowThreads();
31617 (arg1)->SetDropTarget(arg2);
31618
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 Py_INCREF(Py_None); resultobj = Py_None;
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31630 PyObject *resultobj;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 wxPyDropTarget *result;
31633 PyObject * obj0 = 0 ;
31634 char *kwnames[] = {
31635 (char *) "self", NULL
31636 };
31637
31638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31640 if (SWIG_arg_fail(1)) SWIG_fail;
31641 {
31642 PyThreadState* __tstate = wxPyBeginAllowThreads();
31643 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31644
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31656 PyObject *resultobj;
31657 wxWindow *arg1 = (wxWindow *) 0 ;
31658 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31659 PyObject * obj0 = 0 ;
31660 PyObject * obj1 = 0 ;
31661 char *kwnames[] = {
31662 (char *) "self",(char *) "constraints", NULL
31663 };
31664
31665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31667 if (SWIG_arg_fail(1)) SWIG_fail;
31668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31669 if (SWIG_arg_fail(2)) SWIG_fail;
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 (arg1)->SetConstraints(arg2);
31673
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 Py_INCREF(Py_None); resultobj = Py_None;
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31685 PyObject *resultobj;
31686 wxWindow *arg1 = (wxWindow *) 0 ;
31687 wxLayoutConstraints *result;
31688 PyObject * obj0 = 0 ;
31689 char *kwnames[] = {
31690 (char *) "self", NULL
31691 };
31692
31693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31698 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31699
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31704 return resultobj;
31705 fail:
31706 return NULL;
31707 }
31708
31709
31710 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31711 PyObject *resultobj;
31712 wxWindow *arg1 = (wxWindow *) 0 ;
31713 bool arg2 ;
31714 PyObject * obj0 = 0 ;
31715 PyObject * obj1 = 0 ;
31716 char *kwnames[] = {
31717 (char *) "self",(char *) "autoLayout", NULL
31718 };
31719
31720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31722 if (SWIG_arg_fail(1)) SWIG_fail;
31723 {
31724 arg2 = (bool)(SWIG_As_bool(obj1));
31725 if (SWIG_arg_fail(2)) SWIG_fail;
31726 }
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 (arg1)->SetAutoLayout(arg2);
31730
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 Py_INCREF(Py_None); resultobj = Py_None;
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31742 PyObject *resultobj;
31743 wxWindow *arg1 = (wxWindow *) 0 ;
31744 bool result;
31745 PyObject * obj0 = 0 ;
31746 char *kwnames[] = {
31747 (char *) "self", NULL
31748 };
31749
31750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31752 if (SWIG_arg_fail(1)) SWIG_fail;
31753 {
31754 PyThreadState* __tstate = wxPyBeginAllowThreads();
31755 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31756
31757 wxPyEndAllowThreads(__tstate);
31758 if (PyErr_Occurred()) SWIG_fail;
31759 }
31760 {
31761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31762 }
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31770 PyObject *resultobj;
31771 wxWindow *arg1 = (wxWindow *) 0 ;
31772 bool result;
31773 PyObject * obj0 = 0 ;
31774 char *kwnames[] = {
31775 (char *) "self", NULL
31776 };
31777
31778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31780 if (SWIG_arg_fail(1)) SWIG_fail;
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = (bool)(arg1)->Layout();
31784
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 {
31789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31790 }
31791 return resultobj;
31792 fail:
31793 return NULL;
31794 }
31795
31796
31797 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj;
31799 wxWindow *arg1 = (wxWindow *) 0 ;
31800 wxSizer *arg2 = (wxSizer *) 0 ;
31801 bool arg3 = (bool) true ;
31802 PyObject * obj0 = 0 ;
31803 PyObject * obj1 = 0 ;
31804 PyObject * obj2 = 0 ;
31805 char *kwnames[] = {
31806 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31807 };
31808
31809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31811 if (SWIG_arg_fail(1)) SWIG_fail;
31812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31813 if (SWIG_arg_fail(2)) SWIG_fail;
31814 if (obj2) {
31815 {
31816 arg3 = (bool)(SWIG_As_bool(obj2));
31817 if (SWIG_arg_fail(3)) SWIG_fail;
31818 }
31819 }
31820 {
31821 PyThreadState* __tstate = wxPyBeginAllowThreads();
31822 (arg1)->SetSizer(arg2,arg3);
31823
31824 wxPyEndAllowThreads(__tstate);
31825 if (PyErr_Occurred()) SWIG_fail;
31826 }
31827 Py_INCREF(Py_None); resultobj = Py_None;
31828 return resultobj;
31829 fail:
31830 return NULL;
31831 }
31832
31833
31834 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj;
31836 wxWindow *arg1 = (wxWindow *) 0 ;
31837 wxSizer *arg2 = (wxSizer *) 0 ;
31838 bool arg3 = (bool) true ;
31839 PyObject * obj0 = 0 ;
31840 PyObject * obj1 = 0 ;
31841 PyObject * obj2 = 0 ;
31842 char *kwnames[] = {
31843 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31844 };
31845
31846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31848 if (SWIG_arg_fail(1)) SWIG_fail;
31849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31850 if (SWIG_arg_fail(2)) SWIG_fail;
31851 if (obj2) {
31852 {
31853 arg3 = (bool)(SWIG_As_bool(obj2));
31854 if (SWIG_arg_fail(3)) SWIG_fail;
31855 }
31856 }
31857 {
31858 PyThreadState* __tstate = wxPyBeginAllowThreads();
31859 (arg1)->SetSizerAndFit(arg2,arg3);
31860
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 Py_INCREF(Py_None); resultobj = Py_None;
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31872 PyObject *resultobj;
31873 wxWindow *arg1 = (wxWindow *) 0 ;
31874 wxSizer *result;
31875 PyObject * obj0 = 0 ;
31876 char *kwnames[] = {
31877 (char *) "self", NULL
31878 };
31879
31880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31886
31887 wxPyEndAllowThreads(__tstate);
31888 if (PyErr_Occurred()) SWIG_fail;
31889 }
31890 {
31891 resultobj = wxPyMake_wxSizer(result, 0);
31892 }
31893 return resultobj;
31894 fail:
31895 return NULL;
31896 }
31897
31898
31899 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31900 PyObject *resultobj;
31901 wxWindow *arg1 = (wxWindow *) 0 ;
31902 wxSizer *arg2 = (wxSizer *) 0 ;
31903 PyObject * obj0 = 0 ;
31904 PyObject * obj1 = 0 ;
31905 char *kwnames[] = {
31906 (char *) "self",(char *) "sizer", NULL
31907 };
31908
31909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31911 if (SWIG_arg_fail(1)) SWIG_fail;
31912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31913 if (SWIG_arg_fail(2)) SWIG_fail;
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 (arg1)->SetContainingSizer(arg2);
31917
31918 wxPyEndAllowThreads(__tstate);
31919 if (PyErr_Occurred()) SWIG_fail;
31920 }
31921 Py_INCREF(Py_None); resultobj = Py_None;
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31929 PyObject *resultobj;
31930 wxWindow *arg1 = (wxWindow *) 0 ;
31931 wxSizer *result;
31932 PyObject * obj0 = 0 ;
31933 char *kwnames[] = {
31934 (char *) "self", NULL
31935 };
31936
31937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31939 if (SWIG_arg_fail(1)) SWIG_fail;
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31943
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 {
31948 resultobj = wxPyMake_wxSizer(result, 0);
31949 }
31950 return resultobj;
31951 fail:
31952 return NULL;
31953 }
31954
31955
31956 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31957 PyObject *resultobj;
31958 wxWindow *arg1 = (wxWindow *) 0 ;
31959 PyObject * obj0 = 0 ;
31960 char *kwnames[] = {
31961 (char *) "self", NULL
31962 };
31963
31964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(1)) SWIG_fail;
31967 {
31968 PyThreadState* __tstate = wxPyBeginAllowThreads();
31969 (arg1)->InheritAttributes();
31970
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 Py_INCREF(Py_None); resultobj = Py_None;
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31982 PyObject *resultobj;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 bool result;
31985 PyObject * obj0 = 0 ;
31986 char *kwnames[] = {
31987 (char *) "self", NULL
31988 };
31989
31990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31992 if (SWIG_arg_fail(1)) SWIG_fail;
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31996
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32010 PyObject *obj;
32011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32012 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32013 Py_INCREF(obj);
32014 return Py_BuildValue((char *)"");
32015 }
32016 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32017 PyObject *resultobj;
32018 long arg1 ;
32019 wxWindow *arg2 = (wxWindow *) NULL ;
32020 wxWindow *result;
32021 PyObject * obj0 = 0 ;
32022 PyObject * obj1 = 0 ;
32023 char *kwnames[] = {
32024 (char *) "id",(char *) "parent", NULL
32025 };
32026
32027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32028 {
32029 arg1 = (long)(SWIG_As_long(obj0));
32030 if (SWIG_arg_fail(1)) SWIG_fail;
32031 }
32032 if (obj1) {
32033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32034 if (SWIG_arg_fail(2)) SWIG_fail;
32035 }
32036 {
32037 if (!wxPyCheckForApp()) SWIG_fail;
32038 PyThreadState* __tstate = wxPyBeginAllowThreads();
32039 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32040
32041 wxPyEndAllowThreads(__tstate);
32042 if (PyErr_Occurred()) SWIG_fail;
32043 }
32044 {
32045 resultobj = wxPyMake_wxObject(result, 0);
32046 }
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32054 PyObject *resultobj;
32055 wxString *arg1 = 0 ;
32056 wxWindow *arg2 = (wxWindow *) NULL ;
32057 wxWindow *result;
32058 bool temp1 = false ;
32059 PyObject * obj0 = 0 ;
32060 PyObject * obj1 = 0 ;
32061 char *kwnames[] = {
32062 (char *) "name",(char *) "parent", NULL
32063 };
32064
32065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32066 {
32067 arg1 = wxString_in_helper(obj0);
32068 if (arg1 == NULL) SWIG_fail;
32069 temp1 = true;
32070 }
32071 if (obj1) {
32072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32073 if (SWIG_arg_fail(2)) SWIG_fail;
32074 }
32075 {
32076 if (!wxPyCheckForApp()) SWIG_fail;
32077 PyThreadState* __tstate = wxPyBeginAllowThreads();
32078 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32079
32080 wxPyEndAllowThreads(__tstate);
32081 if (PyErr_Occurred()) SWIG_fail;
32082 }
32083 {
32084 resultobj = wxPyMake_wxObject(result, 0);
32085 }
32086 {
32087 if (temp1)
32088 delete arg1;
32089 }
32090 return resultobj;
32091 fail:
32092 {
32093 if (temp1)
32094 delete arg1;
32095 }
32096 return NULL;
32097 }
32098
32099
32100 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj;
32102 wxString *arg1 = 0 ;
32103 wxWindow *arg2 = (wxWindow *) NULL ;
32104 wxWindow *result;
32105 bool temp1 = false ;
32106 PyObject * obj0 = 0 ;
32107 PyObject * obj1 = 0 ;
32108 char *kwnames[] = {
32109 (char *) "label",(char *) "parent", NULL
32110 };
32111
32112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32113 {
32114 arg1 = wxString_in_helper(obj0);
32115 if (arg1 == NULL) SWIG_fail;
32116 temp1 = true;
32117 }
32118 if (obj1) {
32119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32120 if (SWIG_arg_fail(2)) SWIG_fail;
32121 }
32122 {
32123 if (!wxPyCheckForApp()) SWIG_fail;
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32126
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 {
32131 resultobj = wxPyMake_wxObject(result, 0);
32132 }
32133 {
32134 if (temp1)
32135 delete arg1;
32136 }
32137 return resultobj;
32138 fail:
32139 {
32140 if (temp1)
32141 delete arg1;
32142 }
32143 return NULL;
32144 }
32145
32146
32147 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32148 PyObject *resultobj;
32149 wxWindow *arg1 = (wxWindow *) 0 ;
32150 unsigned long arg2 ;
32151 wxWindow *result;
32152 PyObject * obj0 = 0 ;
32153 PyObject * obj1 = 0 ;
32154 char *kwnames[] = {
32155 (char *) "parent",(char *) "_hWnd", NULL
32156 };
32157
32158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32160 if (SWIG_arg_fail(1)) SWIG_fail;
32161 {
32162 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32163 if (SWIG_arg_fail(2)) SWIG_fail;
32164 }
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32168
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 {
32173 resultobj = wxPyMake_wxObject(result, 0);
32174 }
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj;
32183 wxValidator *result;
32184 char *kwnames[] = {
32185 NULL
32186 };
32187
32188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32189 {
32190 PyThreadState* __tstate = wxPyBeginAllowThreads();
32191 result = (wxValidator *)new wxValidator();
32192
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32204 PyObject *resultobj;
32205 wxValidator *arg1 = (wxValidator *) 0 ;
32206 wxValidator *result;
32207 PyObject * obj0 = 0 ;
32208 char *kwnames[] = {
32209 (char *) "self", NULL
32210 };
32211
32212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32214 if (SWIG_arg_fail(1)) SWIG_fail;
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (wxValidator *)(arg1)->Clone();
32218
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = wxPyMake_wxObject(result, 0);
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj;
32233 wxValidator *arg1 = (wxValidator *) 0 ;
32234 wxWindow *arg2 = (wxWindow *) 0 ;
32235 bool result;
32236 PyObject * obj0 = 0 ;
32237 PyObject * obj1 = 0 ;
32238 char *kwnames[] = {
32239 (char *) "self",(char *) "parent", NULL
32240 };
32241
32242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32244 if (SWIG_arg_fail(1)) SWIG_fail;
32245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32246 if (SWIG_arg_fail(2)) SWIG_fail;
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)(arg1)->Validate(arg2);
32250
32251 wxPyEndAllowThreads(__tstate);
32252 if (PyErr_Occurred()) SWIG_fail;
32253 }
32254 {
32255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32256 }
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj;
32265 wxValidator *arg1 = (wxValidator *) 0 ;
32266 bool result;
32267 PyObject * obj0 = 0 ;
32268 char *kwnames[] = {
32269 (char *) "self", NULL
32270 };
32271
32272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32274 if (SWIG_arg_fail(1)) SWIG_fail;
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (bool)(arg1)->TransferToWindow();
32278
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32284 }
32285 return resultobj;
32286 fail:
32287 return NULL;
32288 }
32289
32290
32291 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32292 PyObject *resultobj;
32293 wxValidator *arg1 = (wxValidator *) 0 ;
32294 bool result;
32295 PyObject * obj0 = 0 ;
32296 char *kwnames[] = {
32297 (char *) "self", NULL
32298 };
32299
32300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32302 if (SWIG_arg_fail(1)) SWIG_fail;
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)(arg1)->TransferFromWindow();
32306
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 {
32311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32312 }
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj;
32321 wxValidator *arg1 = (wxValidator *) 0 ;
32322 wxWindow *result;
32323 PyObject * obj0 = 0 ;
32324 char *kwnames[] = {
32325 (char *) "self", NULL
32326 };
32327
32328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32330 if (SWIG_arg_fail(1)) SWIG_fail;
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 result = (wxWindow *)(arg1)->GetWindow();
32334
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 {
32339 resultobj = wxPyMake_wxObject(result, 0);
32340 }
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32348 PyObject *resultobj;
32349 wxValidator *arg1 = (wxValidator *) 0 ;
32350 wxWindow *arg2 = (wxWindow *) 0 ;
32351 PyObject * obj0 = 0 ;
32352 PyObject * obj1 = 0 ;
32353 char *kwnames[] = {
32354 (char *) "self",(char *) "window", NULL
32355 };
32356
32357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32359 if (SWIG_arg_fail(1)) SWIG_fail;
32360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32361 if (SWIG_arg_fail(2)) SWIG_fail;
32362 {
32363 PyThreadState* __tstate = wxPyBeginAllowThreads();
32364 (arg1)->SetWindow(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_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32377 PyObject *resultobj;
32378 bool result;
32379 char *kwnames[] = {
32380 NULL
32381 };
32382
32383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 result = (bool)wxValidator::IsSilent();
32387
32388 wxPyEndAllowThreads(__tstate);
32389 if (PyErr_Occurred()) SWIG_fail;
32390 }
32391 {
32392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32393 }
32394 return resultobj;
32395 fail:
32396 return NULL;
32397 }
32398
32399
32400 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32401 PyObject *resultobj;
32402 int arg1 = (int) true ;
32403 PyObject * obj0 = 0 ;
32404 char *kwnames[] = {
32405 (char *) "doIt", NULL
32406 };
32407
32408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32409 if (obj0) {
32410 {
32411 arg1 = (int)(SWIG_As_int(obj0));
32412 if (SWIG_arg_fail(1)) SWIG_fail;
32413 }
32414 }
32415 {
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 wxValidator::SetBellOnError(arg1);
32418
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 Py_INCREF(Py_None); resultobj = Py_None;
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32430 PyObject *obj;
32431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32432 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32433 Py_INCREF(obj);
32434 return Py_BuildValue((char *)"");
32435 }
32436 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32437 PyObject *resultobj;
32438 wxPyValidator *result;
32439 char *kwnames[] = {
32440 NULL
32441 };
32442
32443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32444 {
32445 PyThreadState* __tstate = wxPyBeginAllowThreads();
32446 result = (wxPyValidator *)new wxPyValidator();
32447
32448 wxPyEndAllowThreads(__tstate);
32449 if (PyErr_Occurred()) SWIG_fail;
32450 }
32451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32459 PyObject *resultobj;
32460 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32461 PyObject *arg2 = (PyObject *) 0 ;
32462 PyObject *arg3 = (PyObject *) 0 ;
32463 int arg4 = (int) true ;
32464 PyObject * obj0 = 0 ;
32465 PyObject * obj1 = 0 ;
32466 PyObject * obj2 = 0 ;
32467 PyObject * obj3 = 0 ;
32468 char *kwnames[] = {
32469 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32470 };
32471
32472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32474 if (SWIG_arg_fail(1)) SWIG_fail;
32475 arg2 = obj1;
32476 arg3 = obj2;
32477 if (obj3) {
32478 {
32479 arg4 = (int)(SWIG_As_int(obj3));
32480 if (SWIG_arg_fail(4)) SWIG_fail;
32481 }
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32486
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 Py_INCREF(Py_None); resultobj = Py_None;
32491 return resultobj;
32492 fail:
32493 return NULL;
32494 }
32495
32496
32497 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32498 PyObject *obj;
32499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32500 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32501 Py_INCREF(obj);
32502 return Py_BuildValue((char *)"");
32503 }
32504 static int _wrap_DefaultValidator_set(PyObject *) {
32505 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32506 return 1;
32507 }
32508
32509
32510 static PyObject *_wrap_DefaultValidator_get(void) {
32511 PyObject *pyobj;
32512
32513 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32514 return pyobj;
32515 }
32516
32517
32518 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj;
32520 wxString const &arg1_defvalue = wxPyEmptyString ;
32521 wxString *arg1 = (wxString *) &arg1_defvalue ;
32522 long arg2 = (long) 0 ;
32523 wxMenu *result;
32524 bool temp1 = false ;
32525 PyObject * obj0 = 0 ;
32526 PyObject * obj1 = 0 ;
32527 char *kwnames[] = {
32528 (char *) "title",(char *) "style", NULL
32529 };
32530
32531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32532 if (obj0) {
32533 {
32534 arg1 = wxString_in_helper(obj0);
32535 if (arg1 == NULL) SWIG_fail;
32536 temp1 = true;
32537 }
32538 }
32539 if (obj1) {
32540 {
32541 arg2 = (long)(SWIG_As_long(obj1));
32542 if (SWIG_arg_fail(2)) SWIG_fail;
32543 }
32544 }
32545 {
32546 if (!wxPyCheckForApp()) SWIG_fail;
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32549
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32554 {
32555 if (temp1)
32556 delete arg1;
32557 }
32558 return resultobj;
32559 fail:
32560 {
32561 if (temp1)
32562 delete arg1;
32563 }
32564 return NULL;
32565 }
32566
32567
32568 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32569 PyObject *resultobj;
32570 wxMenu *arg1 = (wxMenu *) 0 ;
32571 int arg2 ;
32572 wxString *arg3 = 0 ;
32573 wxString const &arg4_defvalue = wxPyEmptyString ;
32574 wxString *arg4 = (wxString *) &arg4_defvalue ;
32575 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32576 wxMenuItem *result;
32577 bool temp3 = false ;
32578 bool temp4 = false ;
32579 PyObject * obj0 = 0 ;
32580 PyObject * obj1 = 0 ;
32581 PyObject * obj2 = 0 ;
32582 PyObject * obj3 = 0 ;
32583 PyObject * obj4 = 0 ;
32584 char *kwnames[] = {
32585 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32586 };
32587
32588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32590 if (SWIG_arg_fail(1)) SWIG_fail;
32591 {
32592 arg2 = (int)(SWIG_As_int(obj1));
32593 if (SWIG_arg_fail(2)) SWIG_fail;
32594 }
32595 {
32596 arg3 = wxString_in_helper(obj2);
32597 if (arg3 == NULL) SWIG_fail;
32598 temp3 = true;
32599 }
32600 if (obj3) {
32601 {
32602 arg4 = wxString_in_helper(obj3);
32603 if (arg4 == NULL) SWIG_fail;
32604 temp4 = true;
32605 }
32606 }
32607 if (obj4) {
32608 {
32609 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32610 if (SWIG_arg_fail(5)) SWIG_fail;
32611 }
32612 }
32613 {
32614 PyThreadState* __tstate = wxPyBeginAllowThreads();
32615 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32616
32617 wxPyEndAllowThreads(__tstate);
32618 if (PyErr_Occurred()) SWIG_fail;
32619 }
32620 {
32621 resultobj = wxPyMake_wxObject(result, 0);
32622 }
32623 {
32624 if (temp3)
32625 delete arg3;
32626 }
32627 {
32628 if (temp4)
32629 delete arg4;
32630 }
32631 return resultobj;
32632 fail:
32633 {
32634 if (temp3)
32635 delete arg3;
32636 }
32637 {
32638 if (temp4)
32639 delete arg4;
32640 }
32641 return NULL;
32642 }
32643
32644
32645 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32646 PyObject *resultobj;
32647 wxMenu *arg1 = (wxMenu *) 0 ;
32648 wxMenuItem *result;
32649 PyObject * obj0 = 0 ;
32650 char *kwnames[] = {
32651 (char *) "self", NULL
32652 };
32653
32654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32656 if (SWIG_arg_fail(1)) SWIG_fail;
32657 {
32658 PyThreadState* __tstate = wxPyBeginAllowThreads();
32659 result = (wxMenuItem *)(arg1)->AppendSeparator();
32660
32661 wxPyEndAllowThreads(__tstate);
32662 if (PyErr_Occurred()) SWIG_fail;
32663 }
32664 {
32665 resultobj = wxPyMake_wxObject(result, 0);
32666 }
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj;
32675 wxMenu *arg1 = (wxMenu *) 0 ;
32676 int arg2 ;
32677 wxString *arg3 = 0 ;
32678 wxString const &arg4_defvalue = wxPyEmptyString ;
32679 wxString *arg4 = (wxString *) &arg4_defvalue ;
32680 wxMenuItem *result;
32681 bool temp3 = false ;
32682 bool temp4 = false ;
32683 PyObject * obj0 = 0 ;
32684 PyObject * obj1 = 0 ;
32685 PyObject * obj2 = 0 ;
32686 PyObject * obj3 = 0 ;
32687 char *kwnames[] = {
32688 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32689 };
32690
32691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32693 if (SWIG_arg_fail(1)) SWIG_fail;
32694 {
32695 arg2 = (int)(SWIG_As_int(obj1));
32696 if (SWIG_arg_fail(2)) SWIG_fail;
32697 }
32698 {
32699 arg3 = wxString_in_helper(obj2);
32700 if (arg3 == NULL) SWIG_fail;
32701 temp3 = true;
32702 }
32703 if (obj3) {
32704 {
32705 arg4 = wxString_in_helper(obj3);
32706 if (arg4 == NULL) SWIG_fail;
32707 temp4 = true;
32708 }
32709 }
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32713
32714 wxPyEndAllowThreads(__tstate);
32715 if (PyErr_Occurred()) SWIG_fail;
32716 }
32717 {
32718 resultobj = wxPyMake_wxObject(result, 0);
32719 }
32720 {
32721 if (temp3)
32722 delete arg3;
32723 }
32724 {
32725 if (temp4)
32726 delete arg4;
32727 }
32728 return resultobj;
32729 fail:
32730 {
32731 if (temp3)
32732 delete arg3;
32733 }
32734 {
32735 if (temp4)
32736 delete arg4;
32737 }
32738 return NULL;
32739 }
32740
32741
32742 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32743 PyObject *resultobj;
32744 wxMenu *arg1 = (wxMenu *) 0 ;
32745 int arg2 ;
32746 wxString *arg3 = 0 ;
32747 wxString const &arg4_defvalue = wxPyEmptyString ;
32748 wxString *arg4 = (wxString *) &arg4_defvalue ;
32749 wxMenuItem *result;
32750 bool temp3 = false ;
32751 bool temp4 = false ;
32752 PyObject * obj0 = 0 ;
32753 PyObject * obj1 = 0 ;
32754 PyObject * obj2 = 0 ;
32755 PyObject * obj3 = 0 ;
32756 char *kwnames[] = {
32757 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32758 };
32759
32760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32762 if (SWIG_arg_fail(1)) SWIG_fail;
32763 {
32764 arg2 = (int)(SWIG_As_int(obj1));
32765 if (SWIG_arg_fail(2)) SWIG_fail;
32766 }
32767 {
32768 arg3 = wxString_in_helper(obj2);
32769 if (arg3 == NULL) SWIG_fail;
32770 temp3 = true;
32771 }
32772 if (obj3) {
32773 {
32774 arg4 = wxString_in_helper(obj3);
32775 if (arg4 == NULL) SWIG_fail;
32776 temp4 = true;
32777 }
32778 }
32779 {
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32782
32783 wxPyEndAllowThreads(__tstate);
32784 if (PyErr_Occurred()) SWIG_fail;
32785 }
32786 {
32787 resultobj = wxPyMake_wxObject(result, 0);
32788 }
32789 {
32790 if (temp3)
32791 delete arg3;
32792 }
32793 {
32794 if (temp4)
32795 delete arg4;
32796 }
32797 return resultobj;
32798 fail:
32799 {
32800 if (temp3)
32801 delete arg3;
32802 }
32803 {
32804 if (temp4)
32805 delete arg4;
32806 }
32807 return NULL;
32808 }
32809
32810
32811 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32812 PyObject *resultobj;
32813 wxMenu *arg1 = (wxMenu *) 0 ;
32814 int arg2 ;
32815 wxString *arg3 = 0 ;
32816 wxMenu *arg4 = (wxMenu *) 0 ;
32817 wxString const &arg5_defvalue = wxPyEmptyString ;
32818 wxString *arg5 = (wxString *) &arg5_defvalue ;
32819 wxMenuItem *result;
32820 bool temp3 = false ;
32821 bool temp5 = false ;
32822 PyObject * obj0 = 0 ;
32823 PyObject * obj1 = 0 ;
32824 PyObject * obj2 = 0 ;
32825 PyObject * obj3 = 0 ;
32826 PyObject * obj4 = 0 ;
32827 char *kwnames[] = {
32828 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32829 };
32830
32831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32833 if (SWIG_arg_fail(1)) SWIG_fail;
32834 {
32835 arg2 = (int)(SWIG_As_int(obj1));
32836 if (SWIG_arg_fail(2)) SWIG_fail;
32837 }
32838 {
32839 arg3 = wxString_in_helper(obj2);
32840 if (arg3 == NULL) SWIG_fail;
32841 temp3 = true;
32842 }
32843 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32844 if (SWIG_arg_fail(4)) SWIG_fail;
32845 if (obj4) {
32846 {
32847 arg5 = wxString_in_helper(obj4);
32848 if (arg5 == NULL) SWIG_fail;
32849 temp5 = true;
32850 }
32851 }
32852 {
32853 PyThreadState* __tstate = wxPyBeginAllowThreads();
32854 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32855
32856 wxPyEndAllowThreads(__tstate);
32857 if (PyErr_Occurred()) SWIG_fail;
32858 }
32859 {
32860 resultobj = wxPyMake_wxObject(result, 0);
32861 }
32862 {
32863 if (temp3)
32864 delete arg3;
32865 }
32866 {
32867 if (temp5)
32868 delete arg5;
32869 }
32870 return resultobj;
32871 fail:
32872 {
32873 if (temp3)
32874 delete arg3;
32875 }
32876 {
32877 if (temp5)
32878 delete arg5;
32879 }
32880 return NULL;
32881 }
32882
32883
32884 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32885 PyObject *resultobj;
32886 wxMenu *arg1 = (wxMenu *) 0 ;
32887 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32888 wxMenuItem *result;
32889 PyObject * obj0 = 0 ;
32890 PyObject * obj1 = 0 ;
32891 char *kwnames[] = {
32892 (char *) "self",(char *) "item", NULL
32893 };
32894
32895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32897 if (SWIG_arg_fail(1)) SWIG_fail;
32898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32899 if (SWIG_arg_fail(2)) SWIG_fail;
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (wxMenuItem *)(arg1)->Append(arg2);
32903
32904 wxPyEndAllowThreads(__tstate);
32905 if (PyErr_Occurred()) SWIG_fail;
32906 }
32907 {
32908 resultobj = wxPyMake_wxObject(result, 0);
32909 }
32910 return resultobj;
32911 fail:
32912 return NULL;
32913 }
32914
32915
32916 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32917 PyObject *resultobj;
32918 wxMenu *arg1 = (wxMenu *) 0 ;
32919 PyObject * obj0 = 0 ;
32920 char *kwnames[] = {
32921 (char *) "self", NULL
32922 };
32923
32924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32926 if (SWIG_arg_fail(1)) SWIG_fail;
32927 {
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 (arg1)->Break();
32930
32931 wxPyEndAllowThreads(__tstate);
32932 if (PyErr_Occurred()) SWIG_fail;
32933 }
32934 Py_INCREF(Py_None); resultobj = Py_None;
32935 return resultobj;
32936 fail:
32937 return NULL;
32938 }
32939
32940
32941 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32942 PyObject *resultobj;
32943 wxMenu *arg1 = (wxMenu *) 0 ;
32944 size_t arg2 ;
32945 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32946 wxMenuItem *result;
32947 PyObject * obj0 = 0 ;
32948 PyObject * obj1 = 0 ;
32949 PyObject * obj2 = 0 ;
32950 char *kwnames[] = {
32951 (char *) "self",(char *) "pos",(char *) "item", NULL
32952 };
32953
32954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32956 if (SWIG_arg_fail(1)) SWIG_fail;
32957 {
32958 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32959 if (SWIG_arg_fail(2)) SWIG_fail;
32960 }
32961 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32962 if (SWIG_arg_fail(3)) SWIG_fail;
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32966
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 {
32971 resultobj = wxPyMake_wxObject(result, 0);
32972 }
32973 return resultobj;
32974 fail:
32975 return NULL;
32976 }
32977
32978
32979 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32980 PyObject *resultobj;
32981 wxMenu *arg1 = (wxMenu *) 0 ;
32982 size_t arg2 ;
32983 int arg3 ;
32984 wxString *arg4 = 0 ;
32985 wxString const &arg5_defvalue = wxPyEmptyString ;
32986 wxString *arg5 = (wxString *) &arg5_defvalue ;
32987 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32988 wxMenuItem *result;
32989 bool temp4 = false ;
32990 bool temp5 = false ;
32991 PyObject * obj0 = 0 ;
32992 PyObject * obj1 = 0 ;
32993 PyObject * obj2 = 0 ;
32994 PyObject * obj3 = 0 ;
32995 PyObject * obj4 = 0 ;
32996 PyObject * obj5 = 0 ;
32997 char *kwnames[] = {
32998 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32999 };
33000
33001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33003 if (SWIG_arg_fail(1)) SWIG_fail;
33004 {
33005 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33006 if (SWIG_arg_fail(2)) SWIG_fail;
33007 }
33008 {
33009 arg3 = (int)(SWIG_As_int(obj2));
33010 if (SWIG_arg_fail(3)) SWIG_fail;
33011 }
33012 {
33013 arg4 = wxString_in_helper(obj3);
33014 if (arg4 == NULL) SWIG_fail;
33015 temp4 = true;
33016 }
33017 if (obj4) {
33018 {
33019 arg5 = wxString_in_helper(obj4);
33020 if (arg5 == NULL) SWIG_fail;
33021 temp5 = true;
33022 }
33023 }
33024 if (obj5) {
33025 {
33026 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33027 if (SWIG_arg_fail(6)) SWIG_fail;
33028 }
33029 }
33030 {
33031 PyThreadState* __tstate = wxPyBeginAllowThreads();
33032 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33033
33034 wxPyEndAllowThreads(__tstate);
33035 if (PyErr_Occurred()) SWIG_fail;
33036 }
33037 {
33038 resultobj = wxPyMake_wxObject(result, 0);
33039 }
33040 {
33041 if (temp4)
33042 delete arg4;
33043 }
33044 {
33045 if (temp5)
33046 delete arg5;
33047 }
33048 return resultobj;
33049 fail:
33050 {
33051 if (temp4)
33052 delete arg4;
33053 }
33054 {
33055 if (temp5)
33056 delete arg5;
33057 }
33058 return NULL;
33059 }
33060
33061
33062 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33063 PyObject *resultobj;
33064 wxMenu *arg1 = (wxMenu *) 0 ;
33065 size_t arg2 ;
33066 wxMenuItem *result;
33067 PyObject * obj0 = 0 ;
33068 PyObject * obj1 = 0 ;
33069 char *kwnames[] = {
33070 (char *) "self",(char *) "pos", NULL
33071 };
33072
33073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33075 if (SWIG_arg_fail(1)) SWIG_fail;
33076 {
33077 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33078 if (SWIG_arg_fail(2)) SWIG_fail;
33079 }
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33083
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 resultobj = wxPyMake_wxObject(result, 0);
33089 }
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33097 PyObject *resultobj;
33098 wxMenu *arg1 = (wxMenu *) 0 ;
33099 size_t arg2 ;
33100 int arg3 ;
33101 wxString *arg4 = 0 ;
33102 wxString const &arg5_defvalue = wxPyEmptyString ;
33103 wxString *arg5 = (wxString *) &arg5_defvalue ;
33104 wxMenuItem *result;
33105 bool temp4 = false ;
33106 bool temp5 = false ;
33107 PyObject * obj0 = 0 ;
33108 PyObject * obj1 = 0 ;
33109 PyObject * obj2 = 0 ;
33110 PyObject * obj3 = 0 ;
33111 PyObject * obj4 = 0 ;
33112 char *kwnames[] = {
33113 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33114 };
33115
33116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33118 if (SWIG_arg_fail(1)) SWIG_fail;
33119 {
33120 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33121 if (SWIG_arg_fail(2)) SWIG_fail;
33122 }
33123 {
33124 arg3 = (int)(SWIG_As_int(obj2));
33125 if (SWIG_arg_fail(3)) SWIG_fail;
33126 }
33127 {
33128 arg4 = wxString_in_helper(obj3);
33129 if (arg4 == NULL) SWIG_fail;
33130 temp4 = true;
33131 }
33132 if (obj4) {
33133 {
33134 arg5 = wxString_in_helper(obj4);
33135 if (arg5 == NULL) SWIG_fail;
33136 temp5 = true;
33137 }
33138 }
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33142
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 {
33150 if (temp4)
33151 delete arg4;
33152 }
33153 {
33154 if (temp5)
33155 delete arg5;
33156 }
33157 return resultobj;
33158 fail:
33159 {
33160 if (temp4)
33161 delete arg4;
33162 }
33163 {
33164 if (temp5)
33165 delete arg5;
33166 }
33167 return NULL;
33168 }
33169
33170
33171 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33172 PyObject *resultobj;
33173 wxMenu *arg1 = (wxMenu *) 0 ;
33174 size_t arg2 ;
33175 int arg3 ;
33176 wxString *arg4 = 0 ;
33177 wxString const &arg5_defvalue = wxPyEmptyString ;
33178 wxString *arg5 = (wxString *) &arg5_defvalue ;
33179 wxMenuItem *result;
33180 bool temp4 = false ;
33181 bool temp5 = false ;
33182 PyObject * obj0 = 0 ;
33183 PyObject * obj1 = 0 ;
33184 PyObject * obj2 = 0 ;
33185 PyObject * obj3 = 0 ;
33186 PyObject * obj4 = 0 ;
33187 char *kwnames[] = {
33188 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33189 };
33190
33191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33193 if (SWIG_arg_fail(1)) SWIG_fail;
33194 {
33195 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33196 if (SWIG_arg_fail(2)) SWIG_fail;
33197 }
33198 {
33199 arg3 = (int)(SWIG_As_int(obj2));
33200 if (SWIG_arg_fail(3)) SWIG_fail;
33201 }
33202 {
33203 arg4 = wxString_in_helper(obj3);
33204 if (arg4 == NULL) SWIG_fail;
33205 temp4 = true;
33206 }
33207 if (obj4) {
33208 {
33209 arg5 = wxString_in_helper(obj4);
33210 if (arg5 == NULL) SWIG_fail;
33211 temp5 = true;
33212 }
33213 }
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33217
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 {
33222 resultobj = wxPyMake_wxObject(result, 0);
33223 }
33224 {
33225 if (temp4)
33226 delete arg4;
33227 }
33228 {
33229 if (temp5)
33230 delete arg5;
33231 }
33232 return resultobj;
33233 fail:
33234 {
33235 if (temp4)
33236 delete arg4;
33237 }
33238 {
33239 if (temp5)
33240 delete arg5;
33241 }
33242 return NULL;
33243 }
33244
33245
33246 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj;
33248 wxMenu *arg1 = (wxMenu *) 0 ;
33249 size_t arg2 ;
33250 int arg3 ;
33251 wxString *arg4 = 0 ;
33252 wxMenu *arg5 = (wxMenu *) 0 ;
33253 wxString const &arg6_defvalue = wxPyEmptyString ;
33254 wxString *arg6 = (wxString *) &arg6_defvalue ;
33255 wxMenuItem *result;
33256 bool temp4 = false ;
33257 bool temp6 = false ;
33258 PyObject * obj0 = 0 ;
33259 PyObject * obj1 = 0 ;
33260 PyObject * obj2 = 0 ;
33261 PyObject * obj3 = 0 ;
33262 PyObject * obj4 = 0 ;
33263 PyObject * obj5 = 0 ;
33264 char *kwnames[] = {
33265 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33266 };
33267
33268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33270 if (SWIG_arg_fail(1)) SWIG_fail;
33271 {
33272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33273 if (SWIG_arg_fail(2)) SWIG_fail;
33274 }
33275 {
33276 arg3 = (int)(SWIG_As_int(obj2));
33277 if (SWIG_arg_fail(3)) SWIG_fail;
33278 }
33279 {
33280 arg4 = wxString_in_helper(obj3);
33281 if (arg4 == NULL) SWIG_fail;
33282 temp4 = true;
33283 }
33284 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33285 if (SWIG_arg_fail(5)) SWIG_fail;
33286 if (obj5) {
33287 {
33288 arg6 = wxString_in_helper(obj5);
33289 if (arg6 == NULL) SWIG_fail;
33290 temp6 = true;
33291 }
33292 }
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33296
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 {
33301 resultobj = wxPyMake_wxObject(result, 0);
33302 }
33303 {
33304 if (temp4)
33305 delete arg4;
33306 }
33307 {
33308 if (temp6)
33309 delete arg6;
33310 }
33311 return resultobj;
33312 fail:
33313 {
33314 if (temp4)
33315 delete arg4;
33316 }
33317 {
33318 if (temp6)
33319 delete arg6;
33320 }
33321 return NULL;
33322 }
33323
33324
33325 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj;
33327 wxMenu *arg1 = (wxMenu *) 0 ;
33328 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33329 wxMenuItem *result;
33330 PyObject * obj0 = 0 ;
33331 PyObject * obj1 = 0 ;
33332 char *kwnames[] = {
33333 (char *) "self",(char *) "item", NULL
33334 };
33335
33336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33338 if (SWIG_arg_fail(1)) SWIG_fail;
33339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33340 if (SWIG_arg_fail(2)) SWIG_fail;
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33344
33345 wxPyEndAllowThreads(__tstate);
33346 if (PyErr_Occurred()) SWIG_fail;
33347 }
33348 {
33349 resultobj = wxPyMake_wxObject(result, 0);
33350 }
33351 return resultobj;
33352 fail:
33353 return NULL;
33354 }
33355
33356
33357 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33358 PyObject *resultobj;
33359 wxMenu *arg1 = (wxMenu *) 0 ;
33360 int arg2 ;
33361 wxString *arg3 = 0 ;
33362 wxString const &arg4_defvalue = wxPyEmptyString ;
33363 wxString *arg4 = (wxString *) &arg4_defvalue ;
33364 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33365 wxMenuItem *result;
33366 bool temp3 = false ;
33367 bool temp4 = false ;
33368 PyObject * obj0 = 0 ;
33369 PyObject * obj1 = 0 ;
33370 PyObject * obj2 = 0 ;
33371 PyObject * obj3 = 0 ;
33372 PyObject * obj4 = 0 ;
33373 char *kwnames[] = {
33374 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33375 };
33376
33377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33379 if (SWIG_arg_fail(1)) SWIG_fail;
33380 {
33381 arg2 = (int)(SWIG_As_int(obj1));
33382 if (SWIG_arg_fail(2)) SWIG_fail;
33383 }
33384 {
33385 arg3 = wxString_in_helper(obj2);
33386 if (arg3 == NULL) SWIG_fail;
33387 temp3 = true;
33388 }
33389 if (obj3) {
33390 {
33391 arg4 = wxString_in_helper(obj3);
33392 if (arg4 == NULL) SWIG_fail;
33393 temp4 = true;
33394 }
33395 }
33396 if (obj4) {
33397 {
33398 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33399 if (SWIG_arg_fail(5)) SWIG_fail;
33400 }
33401 }
33402 {
33403 PyThreadState* __tstate = wxPyBeginAllowThreads();
33404 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33405
33406 wxPyEndAllowThreads(__tstate);
33407 if (PyErr_Occurred()) SWIG_fail;
33408 }
33409 {
33410 resultobj = wxPyMake_wxObject(result, 0);
33411 }
33412 {
33413 if (temp3)
33414 delete arg3;
33415 }
33416 {
33417 if (temp4)
33418 delete arg4;
33419 }
33420 return resultobj;
33421 fail:
33422 {
33423 if (temp3)
33424 delete arg3;
33425 }
33426 {
33427 if (temp4)
33428 delete arg4;
33429 }
33430 return NULL;
33431 }
33432
33433
33434 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33435 PyObject *resultobj;
33436 wxMenu *arg1 = (wxMenu *) 0 ;
33437 wxMenuItem *result;
33438 PyObject * obj0 = 0 ;
33439 char *kwnames[] = {
33440 (char *) "self", NULL
33441 };
33442
33443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33445 if (SWIG_arg_fail(1)) SWIG_fail;
33446 {
33447 PyThreadState* __tstate = wxPyBeginAllowThreads();
33448 result = (wxMenuItem *)(arg1)->PrependSeparator();
33449
33450 wxPyEndAllowThreads(__tstate);
33451 if (PyErr_Occurred()) SWIG_fail;
33452 }
33453 {
33454 resultobj = wxPyMake_wxObject(result, 0);
33455 }
33456 return resultobj;
33457 fail:
33458 return NULL;
33459 }
33460
33461
33462 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33463 PyObject *resultobj;
33464 wxMenu *arg1 = (wxMenu *) 0 ;
33465 int arg2 ;
33466 wxString *arg3 = 0 ;
33467 wxString const &arg4_defvalue = wxPyEmptyString ;
33468 wxString *arg4 = (wxString *) &arg4_defvalue ;
33469 wxMenuItem *result;
33470 bool temp3 = false ;
33471 bool temp4 = false ;
33472 PyObject * obj0 = 0 ;
33473 PyObject * obj1 = 0 ;
33474 PyObject * obj2 = 0 ;
33475 PyObject * obj3 = 0 ;
33476 char *kwnames[] = {
33477 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33478 };
33479
33480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33482 if (SWIG_arg_fail(1)) SWIG_fail;
33483 {
33484 arg2 = (int)(SWIG_As_int(obj1));
33485 if (SWIG_arg_fail(2)) SWIG_fail;
33486 }
33487 {
33488 arg3 = wxString_in_helper(obj2);
33489 if (arg3 == NULL) SWIG_fail;
33490 temp3 = true;
33491 }
33492 if (obj3) {
33493 {
33494 arg4 = wxString_in_helper(obj3);
33495 if (arg4 == NULL) SWIG_fail;
33496 temp4 = true;
33497 }
33498 }
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33502
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 {
33507 resultobj = wxPyMake_wxObject(result, 0);
33508 }
33509 {
33510 if (temp3)
33511 delete arg3;
33512 }
33513 {
33514 if (temp4)
33515 delete arg4;
33516 }
33517 return resultobj;
33518 fail:
33519 {
33520 if (temp3)
33521 delete arg3;
33522 }
33523 {
33524 if (temp4)
33525 delete arg4;
33526 }
33527 return NULL;
33528 }
33529
33530
33531 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33532 PyObject *resultobj;
33533 wxMenu *arg1 = (wxMenu *) 0 ;
33534 int arg2 ;
33535 wxString *arg3 = 0 ;
33536 wxString const &arg4_defvalue = wxPyEmptyString ;
33537 wxString *arg4 = (wxString *) &arg4_defvalue ;
33538 wxMenuItem *result;
33539 bool temp3 = false ;
33540 bool temp4 = false ;
33541 PyObject * obj0 = 0 ;
33542 PyObject * obj1 = 0 ;
33543 PyObject * obj2 = 0 ;
33544 PyObject * obj3 = 0 ;
33545 char *kwnames[] = {
33546 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33547 };
33548
33549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33551 if (SWIG_arg_fail(1)) SWIG_fail;
33552 {
33553 arg2 = (int)(SWIG_As_int(obj1));
33554 if (SWIG_arg_fail(2)) SWIG_fail;
33555 }
33556 {
33557 arg3 = wxString_in_helper(obj2);
33558 if (arg3 == NULL) SWIG_fail;
33559 temp3 = true;
33560 }
33561 if (obj3) {
33562 {
33563 arg4 = wxString_in_helper(obj3);
33564 if (arg4 == NULL) SWIG_fail;
33565 temp4 = true;
33566 }
33567 }
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33571
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = wxPyMake_wxObject(result, 0);
33577 }
33578 {
33579 if (temp3)
33580 delete arg3;
33581 }
33582 {
33583 if (temp4)
33584 delete arg4;
33585 }
33586 return resultobj;
33587 fail:
33588 {
33589 if (temp3)
33590 delete arg3;
33591 }
33592 {
33593 if (temp4)
33594 delete arg4;
33595 }
33596 return NULL;
33597 }
33598
33599
33600 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33601 PyObject *resultobj;
33602 wxMenu *arg1 = (wxMenu *) 0 ;
33603 int arg2 ;
33604 wxString *arg3 = 0 ;
33605 wxMenu *arg4 = (wxMenu *) 0 ;
33606 wxString const &arg5_defvalue = wxPyEmptyString ;
33607 wxString *arg5 = (wxString *) &arg5_defvalue ;
33608 wxMenuItem *result;
33609 bool temp3 = false ;
33610 bool temp5 = false ;
33611 PyObject * obj0 = 0 ;
33612 PyObject * obj1 = 0 ;
33613 PyObject * obj2 = 0 ;
33614 PyObject * obj3 = 0 ;
33615 PyObject * obj4 = 0 ;
33616 char *kwnames[] = {
33617 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33618 };
33619
33620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33622 if (SWIG_arg_fail(1)) SWIG_fail;
33623 {
33624 arg2 = (int)(SWIG_As_int(obj1));
33625 if (SWIG_arg_fail(2)) SWIG_fail;
33626 }
33627 {
33628 arg3 = wxString_in_helper(obj2);
33629 if (arg3 == NULL) SWIG_fail;
33630 temp3 = true;
33631 }
33632 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33633 if (SWIG_arg_fail(4)) SWIG_fail;
33634 if (obj4) {
33635 {
33636 arg5 = wxString_in_helper(obj4);
33637 if (arg5 == NULL) SWIG_fail;
33638 temp5 = true;
33639 }
33640 }
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33644
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = wxPyMake_wxObject(result, 0);
33650 }
33651 {
33652 if (temp3)
33653 delete arg3;
33654 }
33655 {
33656 if (temp5)
33657 delete arg5;
33658 }
33659 return resultobj;
33660 fail:
33661 {
33662 if (temp3)
33663 delete arg3;
33664 }
33665 {
33666 if (temp5)
33667 delete arg5;
33668 }
33669 return NULL;
33670 }
33671
33672
33673 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj;
33675 wxMenu *arg1 = (wxMenu *) 0 ;
33676 int arg2 ;
33677 wxMenuItem *result;
33678 PyObject * obj0 = 0 ;
33679 PyObject * obj1 = 0 ;
33680 char *kwnames[] = {
33681 (char *) "self",(char *) "id", NULL
33682 };
33683
33684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33686 if (SWIG_arg_fail(1)) SWIG_fail;
33687 {
33688 arg2 = (int)(SWIG_As_int(obj1));
33689 if (SWIG_arg_fail(2)) SWIG_fail;
33690 }
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 result = (wxMenuItem *)(arg1)->Remove(arg2);
33694
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 {
33699 resultobj = wxPyMake_wxObject(result, 0);
33700 }
33701 return resultobj;
33702 fail:
33703 return NULL;
33704 }
33705
33706
33707 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33708 PyObject *resultobj;
33709 wxMenu *arg1 = (wxMenu *) 0 ;
33710 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33711 wxMenuItem *result;
33712 PyObject * obj0 = 0 ;
33713 PyObject * obj1 = 0 ;
33714 char *kwnames[] = {
33715 (char *) "self",(char *) "item", NULL
33716 };
33717
33718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33720 if (SWIG_arg_fail(1)) SWIG_fail;
33721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33722 if (SWIG_arg_fail(2)) SWIG_fail;
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 result = (wxMenuItem *)(arg1)->Remove(arg2);
33726
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 {
33731 resultobj = wxPyMake_wxObject(result, 0);
33732 }
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj;
33741 wxMenu *arg1 = (wxMenu *) 0 ;
33742 int arg2 ;
33743 bool result;
33744 PyObject * obj0 = 0 ;
33745 PyObject * obj1 = 0 ;
33746 char *kwnames[] = {
33747 (char *) "self",(char *) "id", NULL
33748 };
33749
33750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33752 if (SWIG_arg_fail(1)) SWIG_fail;
33753 {
33754 arg2 = (int)(SWIG_As_int(obj1));
33755 if (SWIG_arg_fail(2)) SWIG_fail;
33756 }
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (bool)(arg1)->Delete(arg2);
33760
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 {
33765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33766 }
33767 return resultobj;
33768 fail:
33769 return NULL;
33770 }
33771
33772
33773 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33774 PyObject *resultobj;
33775 wxMenu *arg1 = (wxMenu *) 0 ;
33776 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33777 bool result;
33778 PyObject * obj0 = 0 ;
33779 PyObject * obj1 = 0 ;
33780 char *kwnames[] = {
33781 (char *) "self",(char *) "item", NULL
33782 };
33783
33784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33786 if (SWIG_arg_fail(1)) SWIG_fail;
33787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33788 if (SWIG_arg_fail(2)) SWIG_fail;
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 result = (bool)(arg1)->Delete(arg2);
33792
33793 wxPyEndAllowThreads(__tstate);
33794 if (PyErr_Occurred()) SWIG_fail;
33795 }
33796 {
33797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33798 }
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj;
33807 wxMenu *arg1 = (wxMenu *) 0 ;
33808 PyObject * obj0 = 0 ;
33809 char *kwnames[] = {
33810 (char *) "self", NULL
33811 };
33812
33813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33815 if (SWIG_arg_fail(1)) SWIG_fail;
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 wxMenu_Destroy(arg1);
33819
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 Py_INCREF(Py_None); resultobj = Py_None;
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33831 PyObject *resultobj;
33832 wxMenu *arg1 = (wxMenu *) 0 ;
33833 int arg2 ;
33834 bool result;
33835 PyObject * obj0 = 0 ;
33836 PyObject * obj1 = 0 ;
33837 char *kwnames[] = {
33838 (char *) "self",(char *) "id", NULL
33839 };
33840
33841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33843 if (SWIG_arg_fail(1)) SWIG_fail;
33844 {
33845 arg2 = (int)(SWIG_As_int(obj1));
33846 if (SWIG_arg_fail(2)) SWIG_fail;
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 result = (bool)(arg1)->Destroy(arg2);
33851
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 {
33856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33857 }
33858 return resultobj;
33859 fail:
33860 return NULL;
33861 }
33862
33863
33864 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33865 PyObject *resultobj;
33866 wxMenu *arg1 = (wxMenu *) 0 ;
33867 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33868 bool result;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char *kwnames[] = {
33872 (char *) "self",(char *) "item", NULL
33873 };
33874
33875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33877 if (SWIG_arg_fail(1)) SWIG_fail;
33878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33879 if (SWIG_arg_fail(2)) SWIG_fail;
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 result = (bool)(arg1)->Destroy(arg2);
33883
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 {
33888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33889 }
33890 return resultobj;
33891 fail:
33892 return NULL;
33893 }
33894
33895
33896 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33897 PyObject *resultobj;
33898 wxMenu *arg1 = (wxMenu *) 0 ;
33899 size_t result;
33900 PyObject * obj0 = 0 ;
33901 char *kwnames[] = {
33902 (char *) "self", NULL
33903 };
33904
33905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33911
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 {
33916 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33917 }
33918 return resultobj;
33919 fail:
33920 return NULL;
33921 }
33922
33923
33924 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33925 PyObject *resultobj;
33926 wxMenu *arg1 = (wxMenu *) 0 ;
33927 PyObject *result;
33928 PyObject * obj0 = 0 ;
33929 char *kwnames[] = {
33930 (char *) "self", NULL
33931 };
33932
33933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33935 if (SWIG_arg_fail(1)) SWIG_fail;
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33939
33940 wxPyEndAllowThreads(__tstate);
33941 if (PyErr_Occurred()) SWIG_fail;
33942 }
33943 resultobj = result;
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj;
33952 wxMenu *arg1 = (wxMenu *) 0 ;
33953 wxString *arg2 = 0 ;
33954 int result;
33955 bool temp2 = false ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char *kwnames[] = {
33959 (char *) "self",(char *) "item", NULL
33960 };
33961
33962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33964 if (SWIG_arg_fail(1)) SWIG_fail;
33965 {
33966 arg2 = wxString_in_helper(obj1);
33967 if (arg2 == NULL) SWIG_fail;
33968 temp2 = true;
33969 }
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33973
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 {
33978 resultobj = SWIG_From_int((int)(result));
33979 }
33980 {
33981 if (temp2)
33982 delete arg2;
33983 }
33984 return resultobj;
33985 fail:
33986 {
33987 if (temp2)
33988 delete arg2;
33989 }
33990 return NULL;
33991 }
33992
33993
33994 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj;
33996 wxMenu *arg1 = (wxMenu *) 0 ;
33997 int arg2 ;
33998 wxMenuItem *result;
33999 PyObject * obj0 = 0 ;
34000 PyObject * obj1 = 0 ;
34001 char *kwnames[] = {
34002 (char *) "self",(char *) "id", NULL
34003 };
34004
34005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34007 if (SWIG_arg_fail(1)) SWIG_fail;
34008 {
34009 arg2 = (int)(SWIG_As_int(obj1));
34010 if (SWIG_arg_fail(2)) SWIG_fail;
34011 }
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34015
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 {
34020 resultobj = wxPyMake_wxObject(result, 0);
34021 }
34022 return resultobj;
34023 fail:
34024 return NULL;
34025 }
34026
34027
34028 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj;
34030 wxMenu *arg1 = (wxMenu *) 0 ;
34031 size_t arg2 ;
34032 wxMenuItem *result;
34033 PyObject * obj0 = 0 ;
34034 PyObject * obj1 = 0 ;
34035 char *kwnames[] = {
34036 (char *) "self",(char *) "position", NULL
34037 };
34038
34039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34041 if (SWIG_arg_fail(1)) SWIG_fail;
34042 {
34043 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34044 if (SWIG_arg_fail(2)) SWIG_fail;
34045 }
34046 {
34047 PyThreadState* __tstate = wxPyBeginAllowThreads();
34048 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34049
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 {
34054 resultobj = wxPyMake_wxObject(result, 0);
34055 }
34056 return resultobj;
34057 fail:
34058 return NULL;
34059 }
34060
34061
34062 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34063 PyObject *resultobj;
34064 wxMenu *arg1 = (wxMenu *) 0 ;
34065 int arg2 ;
34066 bool arg3 ;
34067 PyObject * obj0 = 0 ;
34068 PyObject * obj1 = 0 ;
34069 PyObject * obj2 = 0 ;
34070 char *kwnames[] = {
34071 (char *) "self",(char *) "id",(char *) "enable", NULL
34072 };
34073
34074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34076 if (SWIG_arg_fail(1)) SWIG_fail;
34077 {
34078 arg2 = (int)(SWIG_As_int(obj1));
34079 if (SWIG_arg_fail(2)) SWIG_fail;
34080 }
34081 {
34082 arg3 = (bool)(SWIG_As_bool(obj2));
34083 if (SWIG_arg_fail(3)) SWIG_fail;
34084 }
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 (arg1)->Enable(arg2,arg3);
34088
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 Py_INCREF(Py_None); resultobj = Py_None;
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34100 PyObject *resultobj;
34101 wxMenu *arg1 = (wxMenu *) 0 ;
34102 int arg2 ;
34103 bool result;
34104 PyObject * obj0 = 0 ;
34105 PyObject * obj1 = 0 ;
34106 char *kwnames[] = {
34107 (char *) "self",(char *) "id", NULL
34108 };
34109
34110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34112 if (SWIG_arg_fail(1)) SWIG_fail;
34113 {
34114 arg2 = (int)(SWIG_As_int(obj1));
34115 if (SWIG_arg_fail(2)) SWIG_fail;
34116 }
34117 {
34118 PyThreadState* __tstate = wxPyBeginAllowThreads();
34119 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34120
34121 wxPyEndAllowThreads(__tstate);
34122 if (PyErr_Occurred()) SWIG_fail;
34123 }
34124 {
34125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34126 }
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34134 PyObject *resultobj;
34135 wxMenu *arg1 = (wxMenu *) 0 ;
34136 int arg2 ;
34137 bool arg3 ;
34138 PyObject * obj0 = 0 ;
34139 PyObject * obj1 = 0 ;
34140 PyObject * obj2 = 0 ;
34141 char *kwnames[] = {
34142 (char *) "self",(char *) "id",(char *) "check", NULL
34143 };
34144
34145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34147 if (SWIG_arg_fail(1)) SWIG_fail;
34148 {
34149 arg2 = (int)(SWIG_As_int(obj1));
34150 if (SWIG_arg_fail(2)) SWIG_fail;
34151 }
34152 {
34153 arg3 = (bool)(SWIG_As_bool(obj2));
34154 if (SWIG_arg_fail(3)) SWIG_fail;
34155 }
34156 {
34157 PyThreadState* __tstate = wxPyBeginAllowThreads();
34158 (arg1)->Check(arg2,arg3);
34159
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 Py_INCREF(Py_None); resultobj = Py_None;
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj;
34172 wxMenu *arg1 = (wxMenu *) 0 ;
34173 int arg2 ;
34174 bool result;
34175 PyObject * obj0 = 0 ;
34176 PyObject * obj1 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self",(char *) "id", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 arg2 = (int)(SWIG_As_int(obj1));
34186 if (SWIG_arg_fail(2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34191
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 {
34196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34197 }
34198 return resultobj;
34199 fail:
34200 return NULL;
34201 }
34202
34203
34204 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34205 PyObject *resultobj;
34206 wxMenu *arg1 = (wxMenu *) 0 ;
34207 int arg2 ;
34208 wxString *arg3 = 0 ;
34209 bool temp3 = false ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char *kwnames[] = {
34214 (char *) "self",(char *) "id",(char *) "label", NULL
34215 };
34216
34217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34219 if (SWIG_arg_fail(1)) SWIG_fail;
34220 {
34221 arg2 = (int)(SWIG_As_int(obj1));
34222 if (SWIG_arg_fail(2)) SWIG_fail;
34223 }
34224 {
34225 arg3 = wxString_in_helper(obj2);
34226 if (arg3 == NULL) SWIG_fail;
34227 temp3 = true;
34228 }
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34232
34233 wxPyEndAllowThreads(__tstate);
34234 if (PyErr_Occurred()) SWIG_fail;
34235 }
34236 Py_INCREF(Py_None); resultobj = Py_None;
34237 {
34238 if (temp3)
34239 delete arg3;
34240 }
34241 return resultobj;
34242 fail:
34243 {
34244 if (temp3)
34245 delete arg3;
34246 }
34247 return NULL;
34248 }
34249
34250
34251 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34252 PyObject *resultobj;
34253 wxMenu *arg1 = (wxMenu *) 0 ;
34254 int arg2 ;
34255 wxString result;
34256 PyObject * obj0 = 0 ;
34257 PyObject * obj1 = 0 ;
34258 char *kwnames[] = {
34259 (char *) "self",(char *) "id", NULL
34260 };
34261
34262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34264 if (SWIG_arg_fail(1)) SWIG_fail;
34265 {
34266 arg2 = (int)(SWIG_As_int(obj1));
34267 if (SWIG_arg_fail(2)) SWIG_fail;
34268 }
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34272
34273 wxPyEndAllowThreads(__tstate);
34274 if (PyErr_Occurred()) SWIG_fail;
34275 }
34276 {
34277 #if wxUSE_UNICODE
34278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34279 #else
34280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34281 #endif
34282 }
34283 return resultobj;
34284 fail:
34285 return NULL;
34286 }
34287
34288
34289 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34290 PyObject *resultobj;
34291 wxMenu *arg1 = (wxMenu *) 0 ;
34292 int arg2 ;
34293 wxString *arg3 = 0 ;
34294 bool temp3 = false ;
34295 PyObject * obj0 = 0 ;
34296 PyObject * obj1 = 0 ;
34297 PyObject * obj2 = 0 ;
34298 char *kwnames[] = {
34299 (char *) "self",(char *) "id",(char *) "helpString", NULL
34300 };
34301
34302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34304 if (SWIG_arg_fail(1)) SWIG_fail;
34305 {
34306 arg2 = (int)(SWIG_As_int(obj1));
34307 if (SWIG_arg_fail(2)) SWIG_fail;
34308 }
34309 {
34310 arg3 = wxString_in_helper(obj2);
34311 if (arg3 == NULL) SWIG_fail;
34312 temp3 = true;
34313 }
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34317
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 Py_INCREF(Py_None); resultobj = Py_None;
34322 {
34323 if (temp3)
34324 delete arg3;
34325 }
34326 return resultobj;
34327 fail:
34328 {
34329 if (temp3)
34330 delete arg3;
34331 }
34332 return NULL;
34333 }
34334
34335
34336 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34337 PyObject *resultobj;
34338 wxMenu *arg1 = (wxMenu *) 0 ;
34339 int arg2 ;
34340 wxString result;
34341 PyObject * obj0 = 0 ;
34342 PyObject * obj1 = 0 ;
34343 char *kwnames[] = {
34344 (char *) "self",(char *) "id", NULL
34345 };
34346
34347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34349 if (SWIG_arg_fail(1)) SWIG_fail;
34350 {
34351 arg2 = (int)(SWIG_As_int(obj1));
34352 if (SWIG_arg_fail(2)) SWIG_fail;
34353 }
34354 {
34355 PyThreadState* __tstate = wxPyBeginAllowThreads();
34356 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34357
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 {
34362 #if wxUSE_UNICODE
34363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34364 #else
34365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34366 #endif
34367 }
34368 return resultobj;
34369 fail:
34370 return NULL;
34371 }
34372
34373
34374 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34375 PyObject *resultobj;
34376 wxMenu *arg1 = (wxMenu *) 0 ;
34377 wxString *arg2 = 0 ;
34378 bool temp2 = false ;
34379 PyObject * obj0 = 0 ;
34380 PyObject * obj1 = 0 ;
34381 char *kwnames[] = {
34382 (char *) "self",(char *) "title", NULL
34383 };
34384
34385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34387 if (SWIG_arg_fail(1)) SWIG_fail;
34388 {
34389 arg2 = wxString_in_helper(obj1);
34390 if (arg2 == NULL) SWIG_fail;
34391 temp2 = true;
34392 }
34393 {
34394 PyThreadState* __tstate = wxPyBeginAllowThreads();
34395 (arg1)->SetTitle((wxString const &)*arg2);
34396
34397 wxPyEndAllowThreads(__tstate);
34398 if (PyErr_Occurred()) SWIG_fail;
34399 }
34400 Py_INCREF(Py_None); resultobj = Py_None;
34401 {
34402 if (temp2)
34403 delete arg2;
34404 }
34405 return resultobj;
34406 fail:
34407 {
34408 if (temp2)
34409 delete arg2;
34410 }
34411 return NULL;
34412 }
34413
34414
34415 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34416 PyObject *resultobj;
34417 wxMenu *arg1 = (wxMenu *) 0 ;
34418 wxString result;
34419 PyObject * obj0 = 0 ;
34420 char *kwnames[] = {
34421 (char *) "self", NULL
34422 };
34423
34424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34426 if (SWIG_arg_fail(1)) SWIG_fail;
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 result = ((wxMenu const *)arg1)->GetTitle();
34430
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 {
34435 #if wxUSE_UNICODE
34436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34437 #else
34438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34439 #endif
34440 }
34441 return resultobj;
34442 fail:
34443 return NULL;
34444 }
34445
34446
34447 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34448 PyObject *resultobj;
34449 wxMenu *arg1 = (wxMenu *) 0 ;
34450 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34451 PyObject * obj0 = 0 ;
34452 PyObject * obj1 = 0 ;
34453 char *kwnames[] = {
34454 (char *) "self",(char *) "handler", NULL
34455 };
34456
34457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34459 if (SWIG_arg_fail(1)) SWIG_fail;
34460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34461 if (SWIG_arg_fail(2)) SWIG_fail;
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 (arg1)->SetEventHandler(arg2);
34465
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 Py_INCREF(Py_None); resultobj = Py_None;
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj;
34478 wxMenu *arg1 = (wxMenu *) 0 ;
34479 wxEvtHandler *result;
34480 PyObject * obj0 = 0 ;
34481 char *kwnames[] = {
34482 (char *) "self", NULL
34483 };
34484
34485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34487 if (SWIG_arg_fail(1)) SWIG_fail;
34488 {
34489 PyThreadState* __tstate = wxPyBeginAllowThreads();
34490 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34491
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 {
34496 resultobj = wxPyMake_wxObject(result, 0);
34497 }
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj;
34506 wxMenu *arg1 = (wxMenu *) 0 ;
34507 wxWindow *arg2 = (wxWindow *) 0 ;
34508 PyObject * obj0 = 0 ;
34509 PyObject * obj1 = 0 ;
34510 char *kwnames[] = {
34511 (char *) "self",(char *) "win", NULL
34512 };
34513
34514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34516 if (SWIG_arg_fail(1)) SWIG_fail;
34517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34518 if (SWIG_arg_fail(2)) SWIG_fail;
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 (arg1)->SetInvokingWindow(arg2);
34522
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 Py_INCREF(Py_None); resultobj = Py_None;
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj;
34535 wxMenu *arg1 = (wxMenu *) 0 ;
34536 wxWindow *result;
34537 PyObject * obj0 = 0 ;
34538 char *kwnames[] = {
34539 (char *) "self", NULL
34540 };
34541
34542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34544 if (SWIG_arg_fail(1)) SWIG_fail;
34545 {
34546 PyThreadState* __tstate = wxPyBeginAllowThreads();
34547 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34548
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 {
34553 resultobj = wxPyMake_wxObject(result, 0);
34554 }
34555 return resultobj;
34556 fail:
34557 return NULL;
34558 }
34559
34560
34561 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34562 PyObject *resultobj;
34563 wxMenu *arg1 = (wxMenu *) 0 ;
34564 long result;
34565 PyObject * obj0 = 0 ;
34566 char *kwnames[] = {
34567 (char *) "self", NULL
34568 };
34569
34570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34572 if (SWIG_arg_fail(1)) SWIG_fail;
34573 {
34574 PyThreadState* __tstate = wxPyBeginAllowThreads();
34575 result = (long)((wxMenu const *)arg1)->GetStyle();
34576
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 {
34581 resultobj = SWIG_From_long((long)(result));
34582 }
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj;
34591 wxMenu *arg1 = (wxMenu *) 0 ;
34592 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34593 PyObject * obj0 = 0 ;
34594 PyObject * obj1 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self",(char *) "source", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 if (obj1) {
34603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34604 if (SWIG_arg_fail(2)) SWIG_fail;
34605 }
34606 {
34607 PyThreadState* __tstate = wxPyBeginAllowThreads();
34608 (arg1)->UpdateUI(arg2);
34609
34610 wxPyEndAllowThreads(__tstate);
34611 if (PyErr_Occurred()) SWIG_fail;
34612 }
34613 Py_INCREF(Py_None); resultobj = Py_None;
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj;
34622 wxMenu *arg1 = (wxMenu *) 0 ;
34623 wxMenuBar *result;
34624 PyObject * obj0 = 0 ;
34625 char *kwnames[] = {
34626 (char *) "self", NULL
34627 };
34628
34629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34631 if (SWIG_arg_fail(1)) SWIG_fail;
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34635
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 {
34640 resultobj = wxPyMake_wxObject(result, 0);
34641 }
34642 return resultobj;
34643 fail:
34644 return NULL;
34645 }
34646
34647
34648 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34649 PyObject *resultobj;
34650 wxMenu *arg1 = (wxMenu *) 0 ;
34651 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34652 PyObject * obj0 = 0 ;
34653 PyObject * obj1 = 0 ;
34654 char *kwnames[] = {
34655 (char *) "self",(char *) "menubar", NULL
34656 };
34657
34658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34660 if (SWIG_arg_fail(1)) SWIG_fail;
34661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34662 if (SWIG_arg_fail(2)) SWIG_fail;
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 (arg1)->Attach(arg2);
34666
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 Py_INCREF(Py_None); resultobj = Py_None;
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34678 PyObject *resultobj;
34679 wxMenu *arg1 = (wxMenu *) 0 ;
34680 PyObject * obj0 = 0 ;
34681 char *kwnames[] = {
34682 (char *) "self", NULL
34683 };
34684
34685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34687 if (SWIG_arg_fail(1)) SWIG_fail;
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 (arg1)->Detach();
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 Py_INCREF(Py_None); resultobj = Py_None;
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34703 PyObject *resultobj;
34704 wxMenu *arg1 = (wxMenu *) 0 ;
34705 bool result;
34706 PyObject * obj0 = 0 ;
34707 char *kwnames[] = {
34708 (char *) "self", NULL
34709 };
34710
34711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34713 if (SWIG_arg_fail(1)) SWIG_fail;
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 result = (bool)((wxMenu const *)arg1)->IsAttached();
34717
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 {
34722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34723 }
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj;
34732 wxMenu *arg1 = (wxMenu *) 0 ;
34733 wxMenu *arg2 = (wxMenu *) 0 ;
34734 PyObject * obj0 = 0 ;
34735 PyObject * obj1 = 0 ;
34736 char *kwnames[] = {
34737 (char *) "self",(char *) "parent", NULL
34738 };
34739
34740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34742 if (SWIG_arg_fail(1)) SWIG_fail;
34743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34744 if (SWIG_arg_fail(2)) SWIG_fail;
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->SetParent(arg2);
34748
34749 wxPyEndAllowThreads(__tstate);
34750 if (PyErr_Occurred()) SWIG_fail;
34751 }
34752 Py_INCREF(Py_None); resultobj = Py_None;
34753 return resultobj;
34754 fail:
34755 return NULL;
34756 }
34757
34758
34759 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34760 PyObject *resultobj;
34761 wxMenu *arg1 = (wxMenu *) 0 ;
34762 wxMenu *result;
34763 PyObject * obj0 = 0 ;
34764 char *kwnames[] = {
34765 (char *) "self", NULL
34766 };
34767
34768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34770 if (SWIG_arg_fail(1)) SWIG_fail;
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34774
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 {
34779 resultobj = wxPyMake_wxObject(result, 0);
34780 }
34781 return resultobj;
34782 fail:
34783 return NULL;
34784 }
34785
34786
34787 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34788 PyObject *obj;
34789 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34790 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34791 Py_INCREF(obj);
34792 return Py_BuildValue((char *)"");
34793 }
34794 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34795 PyObject *resultobj;
34796 long arg1 = (long) 0 ;
34797 wxMenuBar *result;
34798 PyObject * obj0 = 0 ;
34799 char *kwnames[] = {
34800 (char *) "style", NULL
34801 };
34802
34803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34804 if (obj0) {
34805 {
34806 arg1 = (long)(SWIG_As_long(obj0));
34807 if (SWIG_arg_fail(1)) SWIG_fail;
34808 }
34809 }
34810 {
34811 if (!wxPyCheckForApp()) SWIG_fail;
34812 PyThreadState* __tstate = wxPyBeginAllowThreads();
34813 result = (wxMenuBar *)new wxMenuBar(arg1);
34814
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj;
34827 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34828 wxMenu *arg2 = (wxMenu *) 0 ;
34829 wxString *arg3 = 0 ;
34830 bool result;
34831 bool temp3 = false ;
34832 PyObject * obj0 = 0 ;
34833 PyObject * obj1 = 0 ;
34834 PyObject * obj2 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "menu",(char *) "title", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34843 if (SWIG_arg_fail(2)) SWIG_fail;
34844 {
34845 arg3 = wxString_in_helper(obj2);
34846 if (arg3 == NULL) SWIG_fail;
34847 temp3 = true;
34848 }
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34852
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 {
34857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34858 }
34859 {
34860 if (temp3)
34861 delete arg3;
34862 }
34863 return resultobj;
34864 fail:
34865 {
34866 if (temp3)
34867 delete arg3;
34868 }
34869 return NULL;
34870 }
34871
34872
34873 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj;
34875 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34876 size_t arg2 ;
34877 wxMenu *arg3 = (wxMenu *) 0 ;
34878 wxString *arg4 = 0 ;
34879 bool result;
34880 bool temp4 = false ;
34881 PyObject * obj0 = 0 ;
34882 PyObject * obj1 = 0 ;
34883 PyObject * obj2 = 0 ;
34884 PyObject * obj3 = 0 ;
34885 char *kwnames[] = {
34886 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34887 };
34888
34889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34891 if (SWIG_arg_fail(1)) SWIG_fail;
34892 {
34893 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34894 if (SWIG_arg_fail(2)) SWIG_fail;
34895 }
34896 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34897 if (SWIG_arg_fail(3)) SWIG_fail;
34898 {
34899 arg4 = wxString_in_helper(obj3);
34900 if (arg4 == NULL) SWIG_fail;
34901 temp4 = true;
34902 }
34903 {
34904 PyThreadState* __tstate = wxPyBeginAllowThreads();
34905 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34906
34907 wxPyEndAllowThreads(__tstate);
34908 if (PyErr_Occurred()) SWIG_fail;
34909 }
34910 {
34911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34912 }
34913 {
34914 if (temp4)
34915 delete arg4;
34916 }
34917 return resultobj;
34918 fail:
34919 {
34920 if (temp4)
34921 delete arg4;
34922 }
34923 return NULL;
34924 }
34925
34926
34927 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34928 PyObject *resultobj;
34929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34930 size_t result;
34931 PyObject * obj0 = 0 ;
34932 char *kwnames[] = {
34933 (char *) "self", NULL
34934 };
34935
34936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34938 if (SWIG_arg_fail(1)) SWIG_fail;
34939 {
34940 PyThreadState* __tstate = wxPyBeginAllowThreads();
34941 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34942
34943 wxPyEndAllowThreads(__tstate);
34944 if (PyErr_Occurred()) SWIG_fail;
34945 }
34946 {
34947 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34948 }
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34956 PyObject *resultobj;
34957 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34958 size_t arg2 ;
34959 wxMenu *result;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 char *kwnames[] = {
34963 (char *) "self",(char *) "pos", NULL
34964 };
34965
34966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34968 if (SWIG_arg_fail(1)) SWIG_fail;
34969 {
34970 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34971 if (SWIG_arg_fail(2)) SWIG_fail;
34972 }
34973 {
34974 PyThreadState* __tstate = wxPyBeginAllowThreads();
34975 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34976
34977 wxPyEndAllowThreads(__tstate);
34978 if (PyErr_Occurred()) SWIG_fail;
34979 }
34980 {
34981 resultobj = wxPyMake_wxObject(result, 0);
34982 }
34983 return resultobj;
34984 fail:
34985 return NULL;
34986 }
34987
34988
34989 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34990 PyObject *resultobj;
34991 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34992 size_t arg2 ;
34993 wxMenu *arg3 = (wxMenu *) 0 ;
34994 wxString *arg4 = 0 ;
34995 wxMenu *result;
34996 bool temp4 = false ;
34997 PyObject * obj0 = 0 ;
34998 PyObject * obj1 = 0 ;
34999 PyObject * obj2 = 0 ;
35000 PyObject * obj3 = 0 ;
35001 char *kwnames[] = {
35002 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35003 };
35004
35005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35007 if (SWIG_arg_fail(1)) SWIG_fail;
35008 {
35009 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35010 if (SWIG_arg_fail(2)) SWIG_fail;
35011 }
35012 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35013 if (SWIG_arg_fail(3)) SWIG_fail;
35014 {
35015 arg4 = wxString_in_helper(obj3);
35016 if (arg4 == NULL) SWIG_fail;
35017 temp4 = true;
35018 }
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35022
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = wxPyMake_wxObject(result, 0);
35028 }
35029 {
35030 if (temp4)
35031 delete arg4;
35032 }
35033 return resultobj;
35034 fail:
35035 {
35036 if (temp4)
35037 delete arg4;
35038 }
35039 return NULL;
35040 }
35041
35042
35043 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35044 PyObject *resultobj;
35045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35046 size_t arg2 ;
35047 wxMenu *result;
35048 PyObject * obj0 = 0 ;
35049 PyObject * obj1 = 0 ;
35050 char *kwnames[] = {
35051 (char *) "self",(char *) "pos", NULL
35052 };
35053
35054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35056 if (SWIG_arg_fail(1)) SWIG_fail;
35057 {
35058 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35059 if (SWIG_arg_fail(2)) SWIG_fail;
35060 }
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (wxMenu *)(arg1)->Remove(arg2);
35064
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 {
35069 resultobj = wxPyMake_wxObject(result, 0);
35070 }
35071 return resultobj;
35072 fail:
35073 return NULL;
35074 }
35075
35076
35077 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35078 PyObject *resultobj;
35079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35080 size_t arg2 ;
35081 bool arg3 ;
35082 PyObject * obj0 = 0 ;
35083 PyObject * obj1 = 0 ;
35084 PyObject * obj2 = 0 ;
35085 char *kwnames[] = {
35086 (char *) "self",(char *) "pos",(char *) "enable", NULL
35087 };
35088
35089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35091 if (SWIG_arg_fail(1)) SWIG_fail;
35092 {
35093 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35094 if (SWIG_arg_fail(2)) SWIG_fail;
35095 }
35096 {
35097 arg3 = (bool)(SWIG_As_bool(obj2));
35098 if (SWIG_arg_fail(3)) SWIG_fail;
35099 }
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 (arg1)->EnableTop(arg2,arg3);
35103
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 Py_INCREF(Py_None); resultobj = Py_None;
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj;
35116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35117 size_t arg2 ;
35118 bool result;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char *kwnames[] = {
35122 (char *) "self",(char *) "pos", NULL
35123 };
35124
35125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35127 if (SWIG_arg_fail(1)) SWIG_fail;
35128 {
35129 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35130 if (SWIG_arg_fail(2)) SWIG_fail;
35131 }
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35135
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 {
35140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35141 }
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj;
35150 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35151 size_t arg2 ;
35152 wxString *arg3 = 0 ;
35153 bool temp3 = false ;
35154 PyObject * obj0 = 0 ;
35155 PyObject * obj1 = 0 ;
35156 PyObject * obj2 = 0 ;
35157 char *kwnames[] = {
35158 (char *) "self",(char *) "pos",(char *) "label", NULL
35159 };
35160
35161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35163 if (SWIG_arg_fail(1)) SWIG_fail;
35164 {
35165 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35166 if (SWIG_arg_fail(2)) SWIG_fail;
35167 }
35168 {
35169 arg3 = wxString_in_helper(obj2);
35170 if (arg3 == NULL) SWIG_fail;
35171 temp3 = true;
35172 }
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35176
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 Py_INCREF(Py_None); resultobj = Py_None;
35181 {
35182 if (temp3)
35183 delete arg3;
35184 }
35185 return resultobj;
35186 fail:
35187 {
35188 if (temp3)
35189 delete arg3;
35190 }
35191 return NULL;
35192 }
35193
35194
35195 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35196 PyObject *resultobj;
35197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35198 size_t arg2 ;
35199 wxString result;
35200 PyObject * obj0 = 0 ;
35201 PyObject * obj1 = 0 ;
35202 char *kwnames[] = {
35203 (char *) "self",(char *) "pos", NULL
35204 };
35205
35206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35208 if (SWIG_arg_fail(1)) SWIG_fail;
35209 {
35210 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35211 if (SWIG_arg_fail(2)) SWIG_fail;
35212 }
35213 {
35214 PyThreadState* __tstate = wxPyBeginAllowThreads();
35215 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35216
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 {
35221 #if wxUSE_UNICODE
35222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35223 #else
35224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35225 #endif
35226 }
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35234 PyObject *resultobj;
35235 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35236 wxString *arg2 = 0 ;
35237 wxString *arg3 = 0 ;
35238 int result;
35239 bool temp2 = false ;
35240 bool temp3 = false ;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 PyObject * obj2 = 0 ;
35244 char *kwnames[] = {
35245 (char *) "self",(char *) "menu",(char *) "item", NULL
35246 };
35247
35248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35250 if (SWIG_arg_fail(1)) SWIG_fail;
35251 {
35252 arg2 = wxString_in_helper(obj1);
35253 if (arg2 == NULL) SWIG_fail;
35254 temp2 = true;
35255 }
35256 {
35257 arg3 = wxString_in_helper(obj2);
35258 if (arg3 == NULL) SWIG_fail;
35259 temp3 = true;
35260 }
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35264
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 {
35269 resultobj = SWIG_From_int((int)(result));
35270 }
35271 {
35272 if (temp2)
35273 delete arg2;
35274 }
35275 {
35276 if (temp3)
35277 delete arg3;
35278 }
35279 return resultobj;
35280 fail:
35281 {
35282 if (temp2)
35283 delete arg2;
35284 }
35285 {
35286 if (temp3)
35287 delete arg3;
35288 }
35289 return NULL;
35290 }
35291
35292
35293 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35294 PyObject *resultobj;
35295 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35296 int arg2 ;
35297 wxMenuItem *result;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char *kwnames[] = {
35301 (char *) "self",(char *) "id", NULL
35302 };
35303
35304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35306 if (SWIG_arg_fail(1)) SWIG_fail;
35307 {
35308 arg2 = (int)(SWIG_As_int(obj1));
35309 if (SWIG_arg_fail(2)) SWIG_fail;
35310 }
35311 {
35312 PyThreadState* __tstate = wxPyBeginAllowThreads();
35313 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35314
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 {
35319 resultobj = wxPyMake_wxObject(result, 0);
35320 }
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35328 PyObject *resultobj;
35329 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35330 wxString *arg2 = 0 ;
35331 int result;
35332 bool temp2 = false ;
35333 PyObject * obj0 = 0 ;
35334 PyObject * obj1 = 0 ;
35335 char *kwnames[] = {
35336 (char *) "self",(char *) "title", NULL
35337 };
35338
35339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35341 if (SWIG_arg_fail(1)) SWIG_fail;
35342 {
35343 arg2 = wxString_in_helper(obj1);
35344 if (arg2 == NULL) SWIG_fail;
35345 temp2 = true;
35346 }
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35350
35351 wxPyEndAllowThreads(__tstate);
35352 if (PyErr_Occurred()) SWIG_fail;
35353 }
35354 {
35355 resultobj = SWIG_From_int((int)(result));
35356 }
35357 {
35358 if (temp2)
35359 delete arg2;
35360 }
35361 return resultobj;
35362 fail:
35363 {
35364 if (temp2)
35365 delete arg2;
35366 }
35367 return NULL;
35368 }
35369
35370
35371 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35372 PyObject *resultobj;
35373 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35374 int arg2 ;
35375 bool arg3 ;
35376 PyObject * obj0 = 0 ;
35377 PyObject * obj1 = 0 ;
35378 PyObject * obj2 = 0 ;
35379 char *kwnames[] = {
35380 (char *) "self",(char *) "id",(char *) "enable", NULL
35381 };
35382
35383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35385 if (SWIG_arg_fail(1)) SWIG_fail;
35386 {
35387 arg2 = (int)(SWIG_As_int(obj1));
35388 if (SWIG_arg_fail(2)) SWIG_fail;
35389 }
35390 {
35391 arg3 = (bool)(SWIG_As_bool(obj2));
35392 if (SWIG_arg_fail(3)) SWIG_fail;
35393 }
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 (arg1)->Enable(arg2,arg3);
35397
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 Py_INCREF(Py_None); resultobj = Py_None;
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35409 PyObject *resultobj;
35410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35411 int arg2 ;
35412 bool arg3 ;
35413 PyObject * obj0 = 0 ;
35414 PyObject * obj1 = 0 ;
35415 PyObject * obj2 = 0 ;
35416 char *kwnames[] = {
35417 (char *) "self",(char *) "id",(char *) "check", NULL
35418 };
35419
35420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35422 if (SWIG_arg_fail(1)) SWIG_fail;
35423 {
35424 arg2 = (int)(SWIG_As_int(obj1));
35425 if (SWIG_arg_fail(2)) SWIG_fail;
35426 }
35427 {
35428 arg3 = (bool)(SWIG_As_bool(obj2));
35429 if (SWIG_arg_fail(3)) SWIG_fail;
35430 }
35431 {
35432 PyThreadState* __tstate = wxPyBeginAllowThreads();
35433 (arg1)->Check(arg2,arg3);
35434
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 Py_INCREF(Py_None); resultobj = Py_None;
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35446 PyObject *resultobj;
35447 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35448 int arg2 ;
35449 bool result;
35450 PyObject * obj0 = 0 ;
35451 PyObject * obj1 = 0 ;
35452 char *kwnames[] = {
35453 (char *) "self",(char *) "id", NULL
35454 };
35455
35456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35458 if (SWIG_arg_fail(1)) SWIG_fail;
35459 {
35460 arg2 = (int)(SWIG_As_int(obj1));
35461 if (SWIG_arg_fail(2)) SWIG_fail;
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35466
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 {
35471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35472 }
35473 return resultobj;
35474 fail:
35475 return NULL;
35476 }
35477
35478
35479 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35480 PyObject *resultobj;
35481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35482 int arg2 ;
35483 bool result;
35484 PyObject * obj0 = 0 ;
35485 PyObject * obj1 = 0 ;
35486 char *kwnames[] = {
35487 (char *) "self",(char *) "id", NULL
35488 };
35489
35490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35492 if (SWIG_arg_fail(1)) SWIG_fail;
35493 {
35494 arg2 = (int)(SWIG_As_int(obj1));
35495 if (SWIG_arg_fail(2)) SWIG_fail;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35506 }
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj;
35515 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35516 int arg2 ;
35517 wxString *arg3 = 0 ;
35518 bool temp3 = false ;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 PyObject * obj2 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self",(char *) "id",(char *) "label", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 arg2 = (int)(SWIG_As_int(obj1));
35531 if (SWIG_arg_fail(2)) SWIG_fail;
35532 }
35533 {
35534 arg3 = wxString_in_helper(obj2);
35535 if (arg3 == NULL) SWIG_fail;
35536 temp3 = true;
35537 }
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35541
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 Py_INCREF(Py_None); resultobj = Py_None;
35546 {
35547 if (temp3)
35548 delete arg3;
35549 }
35550 return resultobj;
35551 fail:
35552 {
35553 if (temp3)
35554 delete arg3;
35555 }
35556 return NULL;
35557 }
35558
35559
35560 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35561 PyObject *resultobj;
35562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35563 int arg2 ;
35564 wxString result;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 char *kwnames[] = {
35568 (char *) "self",(char *) "id", NULL
35569 };
35570
35571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35573 if (SWIG_arg_fail(1)) SWIG_fail;
35574 {
35575 arg2 = (int)(SWIG_As_int(obj1));
35576 if (SWIG_arg_fail(2)) SWIG_fail;
35577 }
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35581
35582 wxPyEndAllowThreads(__tstate);
35583 if (PyErr_Occurred()) SWIG_fail;
35584 }
35585 {
35586 #if wxUSE_UNICODE
35587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35588 #else
35589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35590 #endif
35591 }
35592 return resultobj;
35593 fail:
35594 return NULL;
35595 }
35596
35597
35598 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35599 PyObject *resultobj;
35600 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35601 int arg2 ;
35602 wxString *arg3 = 0 ;
35603 bool temp3 = false ;
35604 PyObject * obj0 = 0 ;
35605 PyObject * obj1 = 0 ;
35606 PyObject * obj2 = 0 ;
35607 char *kwnames[] = {
35608 (char *) "self",(char *) "id",(char *) "helpString", NULL
35609 };
35610
35611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(1)) SWIG_fail;
35614 {
35615 arg2 = (int)(SWIG_As_int(obj1));
35616 if (SWIG_arg_fail(2)) SWIG_fail;
35617 }
35618 {
35619 arg3 = wxString_in_helper(obj2);
35620 if (arg3 == NULL) SWIG_fail;
35621 temp3 = true;
35622 }
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35626
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 Py_INCREF(Py_None); resultobj = Py_None;
35631 {
35632 if (temp3)
35633 delete arg3;
35634 }
35635 return resultobj;
35636 fail:
35637 {
35638 if (temp3)
35639 delete arg3;
35640 }
35641 return NULL;
35642 }
35643
35644
35645 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35646 PyObject *resultobj;
35647 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35648 int arg2 ;
35649 wxString result;
35650 PyObject * obj0 = 0 ;
35651 PyObject * obj1 = 0 ;
35652 char *kwnames[] = {
35653 (char *) "self",(char *) "id", NULL
35654 };
35655
35656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35658 if (SWIG_arg_fail(1)) SWIG_fail;
35659 {
35660 arg2 = (int)(SWIG_As_int(obj1));
35661 if (SWIG_arg_fail(2)) SWIG_fail;
35662 }
35663 {
35664 PyThreadState* __tstate = wxPyBeginAllowThreads();
35665 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35666
35667 wxPyEndAllowThreads(__tstate);
35668 if (PyErr_Occurred()) SWIG_fail;
35669 }
35670 {
35671 #if wxUSE_UNICODE
35672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35673 #else
35674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35675 #endif
35676 }
35677 return resultobj;
35678 fail:
35679 return NULL;
35680 }
35681
35682
35683 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj;
35685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35686 wxFrame *result;
35687 PyObject * obj0 = 0 ;
35688 char *kwnames[] = {
35689 (char *) "self", NULL
35690 };
35691
35692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35694 if (SWIG_arg_fail(1)) SWIG_fail;
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35698
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = wxPyMake_wxObject(result, 0);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj;
35713 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35714 bool result;
35715 PyObject * obj0 = 0 ;
35716 char *kwnames[] = {
35717 (char *) "self", NULL
35718 };
35719
35720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35722 if (SWIG_arg_fail(1)) SWIG_fail;
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35726
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 {
35731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35732 }
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35740 PyObject *resultobj;
35741 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35742 wxFrame *arg2 = (wxFrame *) 0 ;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 char *kwnames[] = {
35746 (char *) "self",(char *) "frame", NULL
35747 };
35748
35749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35751 if (SWIG_arg_fail(1)) SWIG_fail;
35752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35753 if (SWIG_arg_fail(2)) SWIG_fail;
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 (arg1)->Attach(arg2);
35757
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 Py_INCREF(Py_None); resultobj = Py_None;
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35769 PyObject *resultobj;
35770 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35771 PyObject * obj0 = 0 ;
35772 char *kwnames[] = {
35773 (char *) "self", NULL
35774 };
35775
35776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35778 if (SWIG_arg_fail(1)) SWIG_fail;
35779 {
35780 PyThreadState* __tstate = wxPyBeginAllowThreads();
35781 (arg1)->Detach();
35782
35783 wxPyEndAllowThreads(__tstate);
35784 if (PyErr_Occurred()) SWIG_fail;
35785 }
35786 Py_INCREF(Py_None); resultobj = Py_None;
35787 return resultobj;
35788 fail:
35789 return NULL;
35790 }
35791
35792
35793 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35794 PyObject *obj;
35795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35796 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35797 Py_INCREF(obj);
35798 return Py_BuildValue((char *)"");
35799 }
35800 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35801 PyObject *resultobj;
35802 wxMenu *arg1 = (wxMenu *) NULL ;
35803 int arg2 = (int) wxID_ANY ;
35804 wxString const &arg3_defvalue = wxPyEmptyString ;
35805 wxString *arg3 = (wxString *) &arg3_defvalue ;
35806 wxString const &arg4_defvalue = wxPyEmptyString ;
35807 wxString *arg4 = (wxString *) &arg4_defvalue ;
35808 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35809 wxMenu *arg6 = (wxMenu *) NULL ;
35810 wxMenuItem *result;
35811 bool temp3 = false ;
35812 bool temp4 = false ;
35813 PyObject * obj0 = 0 ;
35814 PyObject * obj1 = 0 ;
35815 PyObject * obj2 = 0 ;
35816 PyObject * obj3 = 0 ;
35817 PyObject * obj4 = 0 ;
35818 PyObject * obj5 = 0 ;
35819 char *kwnames[] = {
35820 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35821 };
35822
35823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35824 if (obj0) {
35825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35826 if (SWIG_arg_fail(1)) SWIG_fail;
35827 }
35828 if (obj1) {
35829 {
35830 arg2 = (int)(SWIG_As_int(obj1));
35831 if (SWIG_arg_fail(2)) SWIG_fail;
35832 }
35833 }
35834 if (obj2) {
35835 {
35836 arg3 = wxString_in_helper(obj2);
35837 if (arg3 == NULL) SWIG_fail;
35838 temp3 = true;
35839 }
35840 }
35841 if (obj3) {
35842 {
35843 arg4 = wxString_in_helper(obj3);
35844 if (arg4 == NULL) SWIG_fail;
35845 temp4 = true;
35846 }
35847 }
35848 if (obj4) {
35849 {
35850 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35851 if (SWIG_arg_fail(5)) SWIG_fail;
35852 }
35853 }
35854 if (obj5) {
35855 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35856 if (SWIG_arg_fail(6)) SWIG_fail;
35857 }
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35861
35862 wxPyEndAllowThreads(__tstate);
35863 if (PyErr_Occurred()) SWIG_fail;
35864 }
35865 {
35866 resultobj = wxPyMake_wxObject(result, 1);
35867 }
35868 {
35869 if (temp3)
35870 delete arg3;
35871 }
35872 {
35873 if (temp4)
35874 delete arg4;
35875 }
35876 return resultobj;
35877 fail:
35878 {
35879 if (temp3)
35880 delete arg3;
35881 }
35882 {
35883 if (temp4)
35884 delete arg4;
35885 }
35886 return NULL;
35887 }
35888
35889
35890 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35891 PyObject *resultobj;
35892 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35893 wxMenu *result;
35894 PyObject * obj0 = 0 ;
35895 char *kwnames[] = {
35896 (char *) "self", NULL
35897 };
35898
35899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35901 if (SWIG_arg_fail(1)) SWIG_fail;
35902 {
35903 PyThreadState* __tstate = wxPyBeginAllowThreads();
35904 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35905
35906 wxPyEndAllowThreads(__tstate);
35907 if (PyErr_Occurred()) SWIG_fail;
35908 }
35909 {
35910 resultobj = wxPyMake_wxObject(result, 0);
35911 }
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj;
35920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35921 wxMenu *arg2 = (wxMenu *) 0 ;
35922 PyObject * obj0 = 0 ;
35923 PyObject * obj1 = 0 ;
35924 char *kwnames[] = {
35925 (char *) "self",(char *) "menu", NULL
35926 };
35927
35928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35930 if (SWIG_arg_fail(1)) SWIG_fail;
35931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35932 if (SWIG_arg_fail(2)) SWIG_fail;
35933 {
35934 PyThreadState* __tstate = wxPyBeginAllowThreads();
35935 (arg1)->SetMenu(arg2);
35936
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 Py_INCREF(Py_None); resultobj = Py_None;
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35948 PyObject *resultobj;
35949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35950 int arg2 ;
35951 PyObject * obj0 = 0 ;
35952 PyObject * obj1 = 0 ;
35953 char *kwnames[] = {
35954 (char *) "self",(char *) "id", NULL
35955 };
35956
35957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35959 if (SWIG_arg_fail(1)) SWIG_fail;
35960 {
35961 arg2 = (int)(SWIG_As_int(obj1));
35962 if (SWIG_arg_fail(2)) SWIG_fail;
35963 }
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 (arg1)->SetId(arg2);
35967
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 Py_INCREF(Py_None); resultobj = Py_None;
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj;
35980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35981 int result;
35982 PyObject * obj0 = 0 ;
35983 char *kwnames[] = {
35984 (char *) "self", NULL
35985 };
35986
35987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35989 if (SWIG_arg_fail(1)) SWIG_fail;
35990 {
35991 PyThreadState* __tstate = wxPyBeginAllowThreads();
35992 result = (int)((wxMenuItem const *)arg1)->GetId();
35993
35994 wxPyEndAllowThreads(__tstate);
35995 if (PyErr_Occurred()) SWIG_fail;
35996 }
35997 {
35998 resultobj = SWIG_From_int((int)(result));
35999 }
36000 return resultobj;
36001 fail:
36002 return NULL;
36003 }
36004
36005
36006 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36007 PyObject *resultobj;
36008 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36009 bool result;
36010 PyObject * obj0 = 0 ;
36011 char *kwnames[] = {
36012 (char *) "self", NULL
36013 };
36014
36015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36017 if (SWIG_arg_fail(1)) SWIG_fail;
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36021
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj;
36036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36037 wxString *arg2 = 0 ;
36038 bool temp2 = false ;
36039 PyObject * obj0 = 0 ;
36040 PyObject * obj1 = 0 ;
36041 char *kwnames[] = {
36042 (char *) "self",(char *) "str", NULL
36043 };
36044
36045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36047 if (SWIG_arg_fail(1)) SWIG_fail;
36048 {
36049 arg2 = wxString_in_helper(obj1);
36050 if (arg2 == NULL) SWIG_fail;
36051 temp2 = true;
36052 }
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 (arg1)->SetText((wxString const &)*arg2);
36056
36057 wxPyEndAllowThreads(__tstate);
36058 if (PyErr_Occurred()) SWIG_fail;
36059 }
36060 Py_INCREF(Py_None); resultobj = Py_None;
36061 {
36062 if (temp2)
36063 delete arg2;
36064 }
36065 return resultobj;
36066 fail:
36067 {
36068 if (temp2)
36069 delete arg2;
36070 }
36071 return NULL;
36072 }
36073
36074
36075 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj;
36077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36078 wxString result;
36079 PyObject * obj0 = 0 ;
36080 char *kwnames[] = {
36081 (char *) "self", NULL
36082 };
36083
36084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36086 if (SWIG_arg_fail(1)) SWIG_fail;
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = ((wxMenuItem const *)arg1)->GetLabel();
36090
36091 wxPyEndAllowThreads(__tstate);
36092 if (PyErr_Occurred()) SWIG_fail;
36093 }
36094 {
36095 #if wxUSE_UNICODE
36096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36097 #else
36098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36099 #endif
36100 }
36101 return resultobj;
36102 fail:
36103 return NULL;
36104 }
36105
36106
36107 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36108 PyObject *resultobj;
36109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36110 wxString *result;
36111 PyObject * obj0 = 0 ;
36112 char *kwnames[] = {
36113 (char *) "self", NULL
36114 };
36115
36116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36118 if (SWIG_arg_fail(1)) SWIG_fail;
36119 {
36120 PyThreadState* __tstate = wxPyBeginAllowThreads();
36121 {
36122 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36123 result = (wxString *) &_result_ref;
36124 }
36125
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 {
36130 #if wxUSE_UNICODE
36131 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36132 #else
36133 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36134 #endif
36135 }
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36143 PyObject *resultobj;
36144 wxString *arg1 = 0 ;
36145 wxString result;
36146 bool temp1 = false ;
36147 PyObject * obj0 = 0 ;
36148 char *kwnames[] = {
36149 (char *) "text", NULL
36150 };
36151
36152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36153 {
36154 arg1 = wxString_in_helper(obj0);
36155 if (arg1 == NULL) SWIG_fail;
36156 temp1 = true;
36157 }
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36161
36162 wxPyEndAllowThreads(__tstate);
36163 if (PyErr_Occurred()) SWIG_fail;
36164 }
36165 {
36166 #if wxUSE_UNICODE
36167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36168 #else
36169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36170 #endif
36171 }
36172 {
36173 if (temp1)
36174 delete arg1;
36175 }
36176 return resultobj;
36177 fail:
36178 {
36179 if (temp1)
36180 delete arg1;
36181 }
36182 return NULL;
36183 }
36184
36185
36186 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36187 PyObject *resultobj;
36188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36189 wxItemKind result;
36190 PyObject * obj0 = 0 ;
36191 char *kwnames[] = {
36192 (char *) "self", NULL
36193 };
36194
36195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36197 if (SWIG_arg_fail(1)) SWIG_fail;
36198 {
36199 PyThreadState* __tstate = wxPyBeginAllowThreads();
36200 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36201
36202 wxPyEndAllowThreads(__tstate);
36203 if (PyErr_Occurred()) SWIG_fail;
36204 }
36205 resultobj = SWIG_From_int((result));
36206 return resultobj;
36207 fail:
36208 return NULL;
36209 }
36210
36211
36212 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36213 PyObject *resultobj;
36214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36215 wxItemKind arg2 ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 char *kwnames[] = {
36219 (char *) "self",(char *) "kind", NULL
36220 };
36221
36222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36224 if (SWIG_arg_fail(1)) SWIG_fail;
36225 {
36226 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36227 if (SWIG_arg_fail(2)) SWIG_fail;
36228 }
36229 {
36230 PyThreadState* __tstate = wxPyBeginAllowThreads();
36231 (arg1)->SetKind((wxItemKind )arg2);
36232
36233 wxPyEndAllowThreads(__tstate);
36234 if (PyErr_Occurred()) SWIG_fail;
36235 }
36236 Py_INCREF(Py_None); resultobj = Py_None;
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36244 PyObject *resultobj;
36245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36246 bool arg2 ;
36247 PyObject * obj0 = 0 ;
36248 PyObject * obj1 = 0 ;
36249 char *kwnames[] = {
36250 (char *) "self",(char *) "checkable", NULL
36251 };
36252
36253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36255 if (SWIG_arg_fail(1)) SWIG_fail;
36256 {
36257 arg2 = (bool)(SWIG_As_bool(obj1));
36258 if (SWIG_arg_fail(2)) SWIG_fail;
36259 }
36260 {
36261 PyThreadState* __tstate = wxPyBeginAllowThreads();
36262 (arg1)->SetCheckable(arg2);
36263
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 Py_INCREF(Py_None); resultobj = Py_None;
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36275 PyObject *resultobj;
36276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36277 bool result;
36278 PyObject * obj0 = 0 ;
36279 char *kwnames[] = {
36280 (char *) "self", NULL
36281 };
36282
36283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36285 if (SWIG_arg_fail(1)) SWIG_fail;
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36289
36290 wxPyEndAllowThreads(__tstate);
36291 if (PyErr_Occurred()) SWIG_fail;
36292 }
36293 {
36294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36295 }
36296 return resultobj;
36297 fail:
36298 return NULL;
36299 }
36300
36301
36302 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj;
36304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36305 bool result;
36306 PyObject * obj0 = 0 ;
36307 char *kwnames[] = {
36308 (char *) "self", NULL
36309 };
36310
36311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36313 if (SWIG_arg_fail(1)) SWIG_fail;
36314 {
36315 PyThreadState* __tstate = wxPyBeginAllowThreads();
36316 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36317
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 {
36322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36323 }
36324 return resultobj;
36325 fail:
36326 return NULL;
36327 }
36328
36329
36330 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36331 PyObject *resultobj;
36332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36333 wxMenu *arg2 = (wxMenu *) 0 ;
36334 PyObject * obj0 = 0 ;
36335 PyObject * obj1 = 0 ;
36336 char *kwnames[] = {
36337 (char *) "self",(char *) "menu", NULL
36338 };
36339
36340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36342 if (SWIG_arg_fail(1)) SWIG_fail;
36343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36344 if (SWIG_arg_fail(2)) SWIG_fail;
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 (arg1)->SetSubMenu(arg2);
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 Py_INCREF(Py_None); resultobj = Py_None;
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj;
36361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36362 wxMenu *result;
36363 PyObject * obj0 = 0 ;
36364 char *kwnames[] = {
36365 (char *) "self", NULL
36366 };
36367
36368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36370 if (SWIG_arg_fail(1)) SWIG_fail;
36371 {
36372 PyThreadState* __tstate = wxPyBeginAllowThreads();
36373 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36374
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 {
36379 resultobj = wxPyMake_wxObject(result, 0);
36380 }
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36388 PyObject *resultobj;
36389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36390 bool arg2 = (bool) true ;
36391 PyObject * obj0 = 0 ;
36392 PyObject * obj1 = 0 ;
36393 char *kwnames[] = {
36394 (char *) "self",(char *) "enable", NULL
36395 };
36396
36397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36399 if (SWIG_arg_fail(1)) SWIG_fail;
36400 if (obj1) {
36401 {
36402 arg2 = (bool)(SWIG_As_bool(obj1));
36403 if (SWIG_arg_fail(2)) SWIG_fail;
36404 }
36405 }
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 (arg1)->Enable(arg2);
36409
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 Py_INCREF(Py_None); resultobj = Py_None;
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36421 PyObject *resultobj;
36422 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36423 bool result;
36424 PyObject * obj0 = 0 ;
36425 char *kwnames[] = {
36426 (char *) "self", NULL
36427 };
36428
36429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36431 if (SWIG_arg_fail(1)) SWIG_fail;
36432 {
36433 PyThreadState* __tstate = wxPyBeginAllowThreads();
36434 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36435
36436 wxPyEndAllowThreads(__tstate);
36437 if (PyErr_Occurred()) SWIG_fail;
36438 }
36439 {
36440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36441 }
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36449 PyObject *resultobj;
36450 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36451 bool arg2 = (bool) true ;
36452 PyObject * obj0 = 0 ;
36453 PyObject * obj1 = 0 ;
36454 char *kwnames[] = {
36455 (char *) "self",(char *) "check", NULL
36456 };
36457
36458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36460 if (SWIG_arg_fail(1)) SWIG_fail;
36461 if (obj1) {
36462 {
36463 arg2 = (bool)(SWIG_As_bool(obj1));
36464 if (SWIG_arg_fail(2)) SWIG_fail;
36465 }
36466 }
36467 {
36468 PyThreadState* __tstate = wxPyBeginAllowThreads();
36469 (arg1)->Check(arg2);
36470
36471 wxPyEndAllowThreads(__tstate);
36472 if (PyErr_Occurred()) SWIG_fail;
36473 }
36474 Py_INCREF(Py_None); resultobj = Py_None;
36475 return resultobj;
36476 fail:
36477 return NULL;
36478 }
36479
36480
36481 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36482 PyObject *resultobj;
36483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36484 bool result;
36485 PyObject * obj0 = 0 ;
36486 char *kwnames[] = {
36487 (char *) "self", NULL
36488 };
36489
36490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36492 if (SWIG_arg_fail(1)) SWIG_fail;
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36496
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 {
36501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36502 }
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj;
36511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36512 PyObject * obj0 = 0 ;
36513 char *kwnames[] = {
36514 (char *) "self", NULL
36515 };
36516
36517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36519 if (SWIG_arg_fail(1)) SWIG_fail;
36520 {
36521 PyThreadState* __tstate = wxPyBeginAllowThreads();
36522 (arg1)->Toggle();
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_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj;
36536 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36537 wxString *arg2 = 0 ;
36538 bool temp2 = false ;
36539 PyObject * obj0 = 0 ;
36540 PyObject * obj1 = 0 ;
36541 char *kwnames[] = {
36542 (char *) "self",(char *) "str", NULL
36543 };
36544
36545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36547 if (SWIG_arg_fail(1)) SWIG_fail;
36548 {
36549 arg2 = wxString_in_helper(obj1);
36550 if (arg2 == NULL) SWIG_fail;
36551 temp2 = true;
36552 }
36553 {
36554 PyThreadState* __tstate = wxPyBeginAllowThreads();
36555 (arg1)->SetHelp((wxString const &)*arg2);
36556
36557 wxPyEndAllowThreads(__tstate);
36558 if (PyErr_Occurred()) SWIG_fail;
36559 }
36560 Py_INCREF(Py_None); resultobj = Py_None;
36561 {
36562 if (temp2)
36563 delete arg2;
36564 }
36565 return resultobj;
36566 fail:
36567 {
36568 if (temp2)
36569 delete arg2;
36570 }
36571 return NULL;
36572 }
36573
36574
36575 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj;
36577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36578 wxString *result;
36579 PyObject * obj0 = 0 ;
36580 char *kwnames[] = {
36581 (char *) "self", NULL
36582 };
36583
36584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36586 if (SWIG_arg_fail(1)) SWIG_fail;
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 {
36590 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36591 result = (wxString *) &_result_ref;
36592 }
36593
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 {
36598 #if wxUSE_UNICODE
36599 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36600 #else
36601 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36602 #endif
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj;
36612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36613 wxAcceleratorEntry *result;
36614 PyObject * obj0 = 0 ;
36615 char *kwnames[] = {
36616 (char *) "self", NULL
36617 };
36618
36619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36621 if (SWIG_arg_fail(1)) SWIG_fail;
36622 {
36623 PyThreadState* __tstate = wxPyBeginAllowThreads();
36624 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36625
36626 wxPyEndAllowThreads(__tstate);
36627 if (PyErr_Occurred()) SWIG_fail;
36628 }
36629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36630 return resultobj;
36631 fail:
36632 return NULL;
36633 }
36634
36635
36636 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36637 PyObject *resultobj;
36638 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36639 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 char *kwnames[] = {
36643 (char *) "self",(char *) "accel", NULL
36644 };
36645
36646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36648 if (SWIG_arg_fail(1)) SWIG_fail;
36649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36650 if (SWIG_arg_fail(2)) SWIG_fail;
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 (arg1)->SetAccel(arg2);
36654
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 Py_INCREF(Py_None); resultobj = Py_None;
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj;
36667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36668 wxFont *arg2 = 0 ;
36669 PyObject * obj0 = 0 ;
36670 PyObject * obj1 = 0 ;
36671 char *kwnames[] = {
36672 (char *) "self",(char *) "font", NULL
36673 };
36674
36675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36677 if (SWIG_arg_fail(1)) SWIG_fail;
36678 {
36679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36680 if (SWIG_arg_fail(2)) SWIG_fail;
36681 if (arg2 == NULL) {
36682 SWIG_null_ref("wxFont");
36683 }
36684 if (SWIG_arg_fail(2)) SWIG_fail;
36685 }
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36689
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 Py_INCREF(Py_None); resultobj = Py_None;
36694 return resultobj;
36695 fail:
36696 return NULL;
36697 }
36698
36699
36700 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36701 PyObject *resultobj;
36702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36703 wxFont result;
36704 PyObject * obj0 = 0 ;
36705 char *kwnames[] = {
36706 (char *) "self", NULL
36707 };
36708
36709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36711 if (SWIG_arg_fail(1)) SWIG_fail;
36712 {
36713 PyThreadState* __tstate = wxPyBeginAllowThreads();
36714 result = wxMenuItem_GetFont(arg1);
36715
36716 wxPyEndAllowThreads(__tstate);
36717 if (PyErr_Occurred()) SWIG_fail;
36718 }
36719 {
36720 wxFont * resultptr;
36721 resultptr = new wxFont((wxFont &)(result));
36722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36723 }
36724 return resultobj;
36725 fail:
36726 return NULL;
36727 }
36728
36729
36730 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36731 PyObject *resultobj;
36732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36733 wxColour *arg2 = 0 ;
36734 wxColour temp2 ;
36735 PyObject * obj0 = 0 ;
36736 PyObject * obj1 = 0 ;
36737 char *kwnames[] = {
36738 (char *) "self",(char *) "colText", NULL
36739 };
36740
36741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36743 if (SWIG_arg_fail(1)) SWIG_fail;
36744 {
36745 arg2 = &temp2;
36746 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36747 }
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36751
36752 wxPyEndAllowThreads(__tstate);
36753 if (PyErr_Occurred()) SWIG_fail;
36754 }
36755 Py_INCREF(Py_None); resultobj = Py_None;
36756 return resultobj;
36757 fail:
36758 return NULL;
36759 }
36760
36761
36762 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj;
36764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36765 wxColour result;
36766 PyObject * obj0 = 0 ;
36767 char *kwnames[] = {
36768 (char *) "self", NULL
36769 };
36770
36771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36773 if (SWIG_arg_fail(1)) SWIG_fail;
36774 {
36775 PyThreadState* __tstate = wxPyBeginAllowThreads();
36776 result = wxMenuItem_GetTextColour(arg1);
36777
36778 wxPyEndAllowThreads(__tstate);
36779 if (PyErr_Occurred()) SWIG_fail;
36780 }
36781 {
36782 wxColour * resultptr;
36783 resultptr = new wxColour((wxColour &)(result));
36784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36785 }
36786 return resultobj;
36787 fail:
36788 return NULL;
36789 }
36790
36791
36792 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36793 PyObject *resultobj;
36794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36795 wxColour *arg2 = 0 ;
36796 wxColour temp2 ;
36797 PyObject * obj0 = 0 ;
36798 PyObject * obj1 = 0 ;
36799 char *kwnames[] = {
36800 (char *) "self",(char *) "colBack", NULL
36801 };
36802
36803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36805 if (SWIG_arg_fail(1)) SWIG_fail;
36806 {
36807 arg2 = &temp2;
36808 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36809 }
36810 {
36811 PyThreadState* __tstate = wxPyBeginAllowThreads();
36812 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36813
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 Py_INCREF(Py_None); resultobj = Py_None;
36818 return resultobj;
36819 fail:
36820 return NULL;
36821 }
36822
36823
36824 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36825 PyObject *resultobj;
36826 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36827 wxColour result;
36828 PyObject * obj0 = 0 ;
36829 char *kwnames[] = {
36830 (char *) "self", NULL
36831 };
36832
36833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36835 if (SWIG_arg_fail(1)) SWIG_fail;
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = wxMenuItem_GetBackgroundColour(arg1);
36839
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 wxColour * resultptr;
36845 resultptr = new wxColour((wxColour &)(result));
36846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36847 }
36848 return resultobj;
36849 fail:
36850 return NULL;
36851 }
36852
36853
36854 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36855 PyObject *resultobj;
36856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36857 wxBitmap *arg2 = 0 ;
36858 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36859 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 PyObject * obj2 = 0 ;
36863 char *kwnames[] = {
36864 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36865 };
36866
36867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36869 if (SWIG_arg_fail(1)) SWIG_fail;
36870 {
36871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36872 if (SWIG_arg_fail(2)) SWIG_fail;
36873 if (arg2 == NULL) {
36874 SWIG_null_ref("wxBitmap");
36875 }
36876 if (SWIG_arg_fail(2)) SWIG_fail;
36877 }
36878 if (obj2) {
36879 {
36880 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36881 if (SWIG_arg_fail(3)) SWIG_fail;
36882 if (arg3 == NULL) {
36883 SWIG_null_ref("wxBitmap");
36884 }
36885 if (SWIG_arg_fail(3)) SWIG_fail;
36886 }
36887 }
36888 {
36889 PyThreadState* __tstate = wxPyBeginAllowThreads();
36890 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36891
36892 wxPyEndAllowThreads(__tstate);
36893 if (PyErr_Occurred()) SWIG_fail;
36894 }
36895 Py_INCREF(Py_None); resultobj = Py_None;
36896 return resultobj;
36897 fail:
36898 return NULL;
36899 }
36900
36901
36902 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36903 PyObject *resultobj;
36904 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36905 wxBitmap *arg2 = 0 ;
36906 PyObject * obj0 = 0 ;
36907 PyObject * obj1 = 0 ;
36908 char *kwnames[] = {
36909 (char *) "self",(char *) "bmpDisabled", NULL
36910 };
36911
36912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36914 if (SWIG_arg_fail(1)) SWIG_fail;
36915 {
36916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36917 if (SWIG_arg_fail(2)) SWIG_fail;
36918 if (arg2 == NULL) {
36919 SWIG_null_ref("wxBitmap");
36920 }
36921 if (SWIG_arg_fail(2)) SWIG_fail;
36922 }
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36926
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 Py_INCREF(Py_None); resultobj = Py_None;
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36938 PyObject *resultobj;
36939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36940 wxBitmap *result;
36941 PyObject * obj0 = 0 ;
36942 char *kwnames[] = {
36943 (char *) "self", NULL
36944 };
36945
36946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36948 if (SWIG_arg_fail(1)) SWIG_fail;
36949 {
36950 PyThreadState* __tstate = wxPyBeginAllowThreads();
36951 {
36952 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36953 result = (wxBitmap *) &_result_ref;
36954 }
36955
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 wxBitmap* resultptr = new wxBitmap(*result);
36961 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36962 }
36963 return resultobj;
36964 fail:
36965 return NULL;
36966 }
36967
36968
36969 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36970 PyObject *resultobj;
36971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36972 int arg2 ;
36973 PyObject * obj0 = 0 ;
36974 PyObject * obj1 = 0 ;
36975 char *kwnames[] = {
36976 (char *) "self",(char *) "nWidth", NULL
36977 };
36978
36979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36981 if (SWIG_arg_fail(1)) SWIG_fail;
36982 {
36983 arg2 = (int)(SWIG_As_int(obj1));
36984 if (SWIG_arg_fail(2)) SWIG_fail;
36985 }
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 wxMenuItem_SetMarginWidth(arg1,arg2);
36989
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 Py_INCREF(Py_None); resultobj = Py_None;
36994 return resultobj;
36995 fail:
36996 return NULL;
36997 }
36998
36999
37000 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37001 PyObject *resultobj;
37002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37003 int result;
37004 PyObject * obj0 = 0 ;
37005 char *kwnames[] = {
37006 (char *) "self", NULL
37007 };
37008
37009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37011 if (SWIG_arg_fail(1)) SWIG_fail;
37012 {
37013 PyThreadState* __tstate = wxPyBeginAllowThreads();
37014 result = (int)wxMenuItem_GetMarginWidth(arg1);
37015
37016 wxPyEndAllowThreads(__tstate);
37017 if (PyErr_Occurred()) SWIG_fail;
37018 }
37019 {
37020 resultobj = SWIG_From_int((int)(result));
37021 }
37022 return resultobj;
37023 fail:
37024 return NULL;
37025 }
37026
37027
37028 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37029 PyObject *resultobj;
37030 int result;
37031 char *kwnames[] = {
37032 NULL
37033 };
37034
37035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = (int)MenuItem_GetDefaultMarginWidth();
37039
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 {
37044 resultobj = SWIG_From_int((int)(result));
37045 }
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj;
37054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37055 bool result;
37056 PyObject * obj0 = 0 ;
37057 char *kwnames[] = {
37058 (char *) "self", NULL
37059 };
37060
37061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37063 if (SWIG_arg_fail(1)) SWIG_fail;
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37067
37068 wxPyEndAllowThreads(__tstate);
37069 if (PyErr_Occurred()) SWIG_fail;
37070 }
37071 {
37072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37073 }
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 bool arg2 = (bool) true ;
37084 PyObject * obj0 = 0 ;
37085 PyObject * obj1 = 0 ;
37086 char *kwnames[] = {
37087 (char *) "self",(char *) "ownerDrawn", NULL
37088 };
37089
37090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37092 if (SWIG_arg_fail(1)) SWIG_fail;
37093 if (obj1) {
37094 {
37095 arg2 = (bool)(SWIG_As_bool(obj1));
37096 if (SWIG_arg_fail(2)) SWIG_fail;
37097 }
37098 }
37099 {
37100 PyThreadState* __tstate = wxPyBeginAllowThreads();
37101 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37102
37103 wxPyEndAllowThreads(__tstate);
37104 if (PyErr_Occurred()) SWIG_fail;
37105 }
37106 Py_INCREF(Py_None); resultobj = Py_None;
37107 return resultobj;
37108 fail:
37109 return NULL;
37110 }
37111
37112
37113 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37114 PyObject *resultobj;
37115 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37116 PyObject * obj0 = 0 ;
37117 char *kwnames[] = {
37118 (char *) "self", NULL
37119 };
37120
37121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37123 if (SWIG_arg_fail(1)) SWIG_fail;
37124 {
37125 PyThreadState* __tstate = wxPyBeginAllowThreads();
37126 wxMenuItem_ResetOwnerDrawn(arg1);
37127
37128 wxPyEndAllowThreads(__tstate);
37129 if (PyErr_Occurred()) SWIG_fail;
37130 }
37131 Py_INCREF(Py_None); resultobj = Py_None;
37132 return resultobj;
37133 fail:
37134 return NULL;
37135 }
37136
37137
37138 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37139 PyObject *resultobj;
37140 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37141 wxBitmap *arg2 = 0 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 char *kwnames[] = {
37145 (char *) "self",(char *) "bitmap", NULL
37146 };
37147
37148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37150 if (SWIG_arg_fail(1)) SWIG_fail;
37151 {
37152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37153 if (SWIG_arg_fail(2)) SWIG_fail;
37154 if (arg2 == NULL) {
37155 SWIG_null_ref("wxBitmap");
37156 }
37157 if (SWIG_arg_fail(2)) SWIG_fail;
37158 }
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37162
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 Py_INCREF(Py_None); resultobj = Py_None;
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37174 PyObject *resultobj;
37175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37176 wxBitmap *result;
37177 PyObject * obj0 = 0 ;
37178 char *kwnames[] = {
37179 (char *) "self", NULL
37180 };
37181
37182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37184 if (SWIG_arg_fail(1)) SWIG_fail;
37185 {
37186 PyThreadState* __tstate = wxPyBeginAllowThreads();
37187 {
37188 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37189 result = (wxBitmap *) &_result_ref;
37190 }
37191
37192 wxPyEndAllowThreads(__tstate);
37193 if (PyErr_Occurred()) SWIG_fail;
37194 }
37195 {
37196 wxBitmap* resultptr = new wxBitmap(*result);
37197 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37198 }
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37206 PyObject *obj;
37207 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37208 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37209 Py_INCREF(obj);
37210 return Py_BuildValue((char *)"");
37211 }
37212 static int _wrap_ControlNameStr_set(PyObject *) {
37213 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37214 return 1;
37215 }
37216
37217
37218 static PyObject *_wrap_ControlNameStr_get(void) {
37219 PyObject *pyobj;
37220
37221 {
37222 #if wxUSE_UNICODE
37223 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37224 #else
37225 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37226 #endif
37227 }
37228 return pyobj;
37229 }
37230
37231
37232 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37233 PyObject *resultobj;
37234 wxWindow *arg1 = (wxWindow *) 0 ;
37235 int arg2 = (int) -1 ;
37236 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37237 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37238 wxSize const &arg4_defvalue = wxDefaultSize ;
37239 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37240 long arg5 = (long) 0 ;
37241 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37242 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37243 wxString const &arg7_defvalue = wxPyControlNameStr ;
37244 wxString *arg7 = (wxString *) &arg7_defvalue ;
37245 wxControl *result;
37246 wxPoint temp3 ;
37247 wxSize temp4 ;
37248 bool temp7 = false ;
37249 PyObject * obj0 = 0 ;
37250 PyObject * obj1 = 0 ;
37251 PyObject * obj2 = 0 ;
37252 PyObject * obj3 = 0 ;
37253 PyObject * obj4 = 0 ;
37254 PyObject * obj5 = 0 ;
37255 PyObject * obj6 = 0 ;
37256 char *kwnames[] = {
37257 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37258 };
37259
37260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37262 if (SWIG_arg_fail(1)) SWIG_fail;
37263 if (obj1) {
37264 {
37265 arg2 = (int)(SWIG_As_int(obj1));
37266 if (SWIG_arg_fail(2)) SWIG_fail;
37267 }
37268 }
37269 if (obj2) {
37270 {
37271 arg3 = &temp3;
37272 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37273 }
37274 }
37275 if (obj3) {
37276 {
37277 arg4 = &temp4;
37278 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37279 }
37280 }
37281 if (obj4) {
37282 {
37283 arg5 = (long)(SWIG_As_long(obj4));
37284 if (SWIG_arg_fail(5)) SWIG_fail;
37285 }
37286 }
37287 if (obj5) {
37288 {
37289 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37290 if (SWIG_arg_fail(6)) SWIG_fail;
37291 if (arg6 == NULL) {
37292 SWIG_null_ref("wxValidator");
37293 }
37294 if (SWIG_arg_fail(6)) SWIG_fail;
37295 }
37296 }
37297 if (obj6) {
37298 {
37299 arg7 = wxString_in_helper(obj6);
37300 if (arg7 == NULL) SWIG_fail;
37301 temp7 = true;
37302 }
37303 }
37304 {
37305 if (!wxPyCheckForApp()) SWIG_fail;
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37308
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37313 {
37314 if (temp7)
37315 delete arg7;
37316 }
37317 return resultobj;
37318 fail:
37319 {
37320 if (temp7)
37321 delete arg7;
37322 }
37323 return NULL;
37324 }
37325
37326
37327 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37328 PyObject *resultobj;
37329 wxControl *result;
37330 char *kwnames[] = {
37331 NULL
37332 };
37333
37334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37335 {
37336 if (!wxPyCheckForApp()) SWIG_fail;
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 result = (wxControl *)new wxControl();
37339
37340 wxPyEndAllowThreads(__tstate);
37341 if (PyErr_Occurred()) SWIG_fail;
37342 }
37343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37344 return resultobj;
37345 fail:
37346 return NULL;
37347 }
37348
37349
37350 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37351 PyObject *resultobj;
37352 wxControl *arg1 = (wxControl *) 0 ;
37353 wxWindow *arg2 = (wxWindow *) 0 ;
37354 int arg3 = (int) -1 ;
37355 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37356 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37357 wxSize const &arg5_defvalue = wxDefaultSize ;
37358 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37359 long arg6 = (long) 0 ;
37360 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37361 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37362 wxString const &arg8_defvalue = wxPyControlNameStr ;
37363 wxString *arg8 = (wxString *) &arg8_defvalue ;
37364 bool result;
37365 wxPoint temp4 ;
37366 wxSize temp5 ;
37367 bool temp8 = false ;
37368 PyObject * obj0 = 0 ;
37369 PyObject * obj1 = 0 ;
37370 PyObject * obj2 = 0 ;
37371 PyObject * obj3 = 0 ;
37372 PyObject * obj4 = 0 ;
37373 PyObject * obj5 = 0 ;
37374 PyObject * obj6 = 0 ;
37375 PyObject * obj7 = 0 ;
37376 char *kwnames[] = {
37377 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37378 };
37379
37380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37382 if (SWIG_arg_fail(1)) SWIG_fail;
37383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37384 if (SWIG_arg_fail(2)) SWIG_fail;
37385 if (obj2) {
37386 {
37387 arg3 = (int)(SWIG_As_int(obj2));
37388 if (SWIG_arg_fail(3)) SWIG_fail;
37389 }
37390 }
37391 if (obj3) {
37392 {
37393 arg4 = &temp4;
37394 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37395 }
37396 }
37397 if (obj4) {
37398 {
37399 arg5 = &temp5;
37400 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37401 }
37402 }
37403 if (obj5) {
37404 {
37405 arg6 = (long)(SWIG_As_long(obj5));
37406 if (SWIG_arg_fail(6)) SWIG_fail;
37407 }
37408 }
37409 if (obj6) {
37410 {
37411 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37412 if (SWIG_arg_fail(7)) SWIG_fail;
37413 if (arg7 == NULL) {
37414 SWIG_null_ref("wxValidator");
37415 }
37416 if (SWIG_arg_fail(7)) SWIG_fail;
37417 }
37418 }
37419 if (obj7) {
37420 {
37421 arg8 = wxString_in_helper(obj7);
37422 if (arg8 == NULL) SWIG_fail;
37423 temp8 = true;
37424 }
37425 }
37426 {
37427 PyThreadState* __tstate = wxPyBeginAllowThreads();
37428 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37429
37430 wxPyEndAllowThreads(__tstate);
37431 if (PyErr_Occurred()) SWIG_fail;
37432 }
37433 {
37434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37435 }
37436 {
37437 if (temp8)
37438 delete arg8;
37439 }
37440 return resultobj;
37441 fail:
37442 {
37443 if (temp8)
37444 delete arg8;
37445 }
37446 return NULL;
37447 }
37448
37449
37450 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37451 PyObject *resultobj;
37452 wxControl *arg1 = (wxControl *) 0 ;
37453 wxCommandEvent *arg2 = 0 ;
37454 PyObject * obj0 = 0 ;
37455 PyObject * obj1 = 0 ;
37456 char *kwnames[] = {
37457 (char *) "self",(char *) "event", NULL
37458 };
37459
37460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37462 if (SWIG_arg_fail(1)) SWIG_fail;
37463 {
37464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37465 if (SWIG_arg_fail(2)) SWIG_fail;
37466 if (arg2 == NULL) {
37467 SWIG_null_ref("wxCommandEvent");
37468 }
37469 if (SWIG_arg_fail(2)) SWIG_fail;
37470 }
37471 {
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 (arg1)->Command(*arg2);
37474
37475 wxPyEndAllowThreads(__tstate);
37476 if (PyErr_Occurred()) SWIG_fail;
37477 }
37478 Py_INCREF(Py_None); resultobj = Py_None;
37479 return resultobj;
37480 fail:
37481 return NULL;
37482 }
37483
37484
37485 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37486 PyObject *resultobj;
37487 wxControl *arg1 = (wxControl *) 0 ;
37488 wxString result;
37489 PyObject * obj0 = 0 ;
37490 char *kwnames[] = {
37491 (char *) "self", NULL
37492 };
37493
37494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37496 if (SWIG_arg_fail(1)) SWIG_fail;
37497 {
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 result = (arg1)->GetLabel();
37500
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 {
37505 #if wxUSE_UNICODE
37506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37507 #else
37508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37509 #endif
37510 }
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj;
37519 wxControl *arg1 = (wxControl *) 0 ;
37520 wxString *arg2 = 0 ;
37521 bool temp2 = false ;
37522 PyObject * obj0 = 0 ;
37523 PyObject * obj1 = 0 ;
37524 char *kwnames[] = {
37525 (char *) "self",(char *) "label", NULL
37526 };
37527
37528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37530 if (SWIG_arg_fail(1)) SWIG_fail;
37531 {
37532 arg2 = wxString_in_helper(obj1);
37533 if (arg2 == NULL) SWIG_fail;
37534 temp2 = true;
37535 }
37536 {
37537 PyThreadState* __tstate = wxPyBeginAllowThreads();
37538 (arg1)->SetLabel((wxString const &)*arg2);
37539
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 Py_INCREF(Py_None); resultobj = Py_None;
37544 {
37545 if (temp2)
37546 delete arg2;
37547 }
37548 return resultobj;
37549 fail:
37550 {
37551 if (temp2)
37552 delete arg2;
37553 }
37554 return NULL;
37555 }
37556
37557
37558 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37559 PyObject *resultobj;
37560 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37561 wxVisualAttributes result;
37562 PyObject * obj0 = 0 ;
37563 char *kwnames[] = {
37564 (char *) "variant", NULL
37565 };
37566
37567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37568 if (obj0) {
37569 {
37570 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37571 if (SWIG_arg_fail(1)) SWIG_fail;
37572 }
37573 }
37574 {
37575 if (!wxPyCheckForApp()) SWIG_fail;
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37578
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 wxVisualAttributes * resultptr;
37584 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37586 }
37587 return resultobj;
37588 fail:
37589 return NULL;
37590 }
37591
37592
37593 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37594 PyObject *obj;
37595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37596 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37597 Py_INCREF(obj);
37598 return Py_BuildValue((char *)"");
37599 }
37600 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37601 PyObject *resultobj;
37602 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37603 wxString *arg2 = 0 ;
37604 PyObject *arg3 = (PyObject *) NULL ;
37605 int result;
37606 bool temp2 = false ;
37607 PyObject * obj0 = 0 ;
37608 PyObject * obj1 = 0 ;
37609 PyObject * obj2 = 0 ;
37610 char *kwnames[] = {
37611 (char *) "self",(char *) "item",(char *) "clientData", NULL
37612 };
37613
37614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37616 if (SWIG_arg_fail(1)) SWIG_fail;
37617 {
37618 arg2 = wxString_in_helper(obj1);
37619 if (arg2 == NULL) SWIG_fail;
37620 temp2 = true;
37621 }
37622 if (obj2) {
37623 arg3 = obj2;
37624 }
37625 {
37626 PyThreadState* __tstate = wxPyBeginAllowThreads();
37627 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37628
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 {
37633 resultobj = SWIG_From_int((int)(result));
37634 }
37635 {
37636 if (temp2)
37637 delete arg2;
37638 }
37639 return resultobj;
37640 fail:
37641 {
37642 if (temp2)
37643 delete arg2;
37644 }
37645 return NULL;
37646 }
37647
37648
37649 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37650 PyObject *resultobj;
37651 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37652 wxArrayString *arg2 = 0 ;
37653 bool temp2 = false ;
37654 PyObject * obj0 = 0 ;
37655 PyObject * obj1 = 0 ;
37656 char *kwnames[] = {
37657 (char *) "self",(char *) "strings", NULL
37658 };
37659
37660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37662 if (SWIG_arg_fail(1)) SWIG_fail;
37663 {
37664 if (! PySequence_Check(obj1)) {
37665 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37666 SWIG_fail;
37667 }
37668 arg2 = new wxArrayString;
37669 temp2 = true;
37670 int i, len=PySequence_Length(obj1);
37671 for (i=0; i<len; i++) {
37672 PyObject* item = PySequence_GetItem(obj1, i);
37673 #if wxUSE_UNICODE
37674 PyObject* str = PyObject_Unicode(item);
37675 #else
37676 PyObject* str = PyObject_Str(item);
37677 #endif
37678 if (PyErr_Occurred()) SWIG_fail;
37679 arg2->Add(Py2wxString(str));
37680 Py_DECREF(item);
37681 Py_DECREF(str);
37682 }
37683 }
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 (arg1)->Append((wxArrayString const &)*arg2);
37687
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 Py_INCREF(Py_None); resultobj = Py_None;
37692 {
37693 if (temp2) delete arg2;
37694 }
37695 return resultobj;
37696 fail:
37697 {
37698 if (temp2) delete arg2;
37699 }
37700 return NULL;
37701 }
37702
37703
37704 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj;
37706 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37707 wxString *arg2 = 0 ;
37708 int arg3 ;
37709 PyObject *arg4 = (PyObject *) NULL ;
37710 int result;
37711 bool temp2 = false ;
37712 PyObject * obj0 = 0 ;
37713 PyObject * obj1 = 0 ;
37714 PyObject * obj2 = 0 ;
37715 PyObject * obj3 = 0 ;
37716 char *kwnames[] = {
37717 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37718 };
37719
37720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37722 if (SWIG_arg_fail(1)) SWIG_fail;
37723 {
37724 arg2 = wxString_in_helper(obj1);
37725 if (arg2 == NULL) SWIG_fail;
37726 temp2 = true;
37727 }
37728 {
37729 arg3 = (int)(SWIG_As_int(obj2));
37730 if (SWIG_arg_fail(3)) SWIG_fail;
37731 }
37732 if (obj3) {
37733 arg4 = obj3;
37734 }
37735 {
37736 PyThreadState* __tstate = wxPyBeginAllowThreads();
37737 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37738
37739 wxPyEndAllowThreads(__tstate);
37740 if (PyErr_Occurred()) SWIG_fail;
37741 }
37742 {
37743 resultobj = SWIG_From_int((int)(result));
37744 }
37745 {
37746 if (temp2)
37747 delete arg2;
37748 }
37749 return resultobj;
37750 fail:
37751 {
37752 if (temp2)
37753 delete arg2;
37754 }
37755 return NULL;
37756 }
37757
37758
37759 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37760 PyObject *resultobj;
37761 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37762 PyObject * obj0 = 0 ;
37763 char *kwnames[] = {
37764 (char *) "self", NULL
37765 };
37766
37767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37769 if (SWIG_arg_fail(1)) SWIG_fail;
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 (arg1)->Clear();
37773
37774 wxPyEndAllowThreads(__tstate);
37775 if (PyErr_Occurred()) SWIG_fail;
37776 }
37777 Py_INCREF(Py_None); resultobj = Py_None;
37778 return resultobj;
37779 fail:
37780 return NULL;
37781 }
37782
37783
37784 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37785 PyObject *resultobj;
37786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37787 int arg2 ;
37788 PyObject * obj0 = 0 ;
37789 PyObject * obj1 = 0 ;
37790 char *kwnames[] = {
37791 (char *) "self",(char *) "n", NULL
37792 };
37793
37794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37796 if (SWIG_arg_fail(1)) SWIG_fail;
37797 {
37798 arg2 = (int)(SWIG_As_int(obj1));
37799 if (SWIG_arg_fail(2)) SWIG_fail;
37800 }
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 (arg1)->Delete(arg2);
37804
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 Py_INCREF(Py_None); resultobj = Py_None;
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37816 PyObject *resultobj;
37817 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37818 int arg2 ;
37819 PyObject *result;
37820 PyObject * obj0 = 0 ;
37821 PyObject * obj1 = 0 ;
37822 char *kwnames[] = {
37823 (char *) "self",(char *) "n", NULL
37824 };
37825
37826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37828 if (SWIG_arg_fail(1)) SWIG_fail;
37829 {
37830 arg2 = (int)(SWIG_As_int(obj1));
37831 if (SWIG_arg_fail(2)) SWIG_fail;
37832 }
37833 {
37834 PyThreadState* __tstate = wxPyBeginAllowThreads();
37835 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37836
37837 wxPyEndAllowThreads(__tstate);
37838 if (PyErr_Occurred()) SWIG_fail;
37839 }
37840 resultobj = result;
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37848 PyObject *resultobj;
37849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37850 int arg2 ;
37851 PyObject *arg3 = (PyObject *) 0 ;
37852 PyObject * obj0 = 0 ;
37853 PyObject * obj1 = 0 ;
37854 PyObject * obj2 = 0 ;
37855 char *kwnames[] = {
37856 (char *) "self",(char *) "n",(char *) "clientData", NULL
37857 };
37858
37859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37861 if (SWIG_arg_fail(1)) SWIG_fail;
37862 {
37863 arg2 = (int)(SWIG_As_int(obj1));
37864 if (SWIG_arg_fail(2)) SWIG_fail;
37865 }
37866 arg3 = obj2;
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 wxItemContainer_SetClientData(arg1,arg2,arg3);
37870
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 Py_INCREF(Py_None); resultobj = Py_None;
37875 return resultobj;
37876 fail:
37877 return NULL;
37878 }
37879
37880
37881 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37882 PyObject *resultobj;
37883 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37884 int result;
37885 PyObject * obj0 = 0 ;
37886 char *kwnames[] = {
37887 (char *) "self", NULL
37888 };
37889
37890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37892 if (SWIG_arg_fail(1)) SWIG_fail;
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 result = (int)((wxItemContainer const *)arg1)->GetCount();
37896
37897 wxPyEndAllowThreads(__tstate);
37898 if (PyErr_Occurred()) SWIG_fail;
37899 }
37900 {
37901 resultobj = SWIG_From_int((int)(result));
37902 }
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37912 bool result;
37913 PyObject * obj0 = 0 ;
37914 char *kwnames[] = {
37915 (char *) "self", NULL
37916 };
37917
37918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37920 if (SWIG_arg_fail(1)) SWIG_fail;
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37924
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 {
37929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37930 }
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj;
37939 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37940 int arg2 ;
37941 wxString result;
37942 PyObject * obj0 = 0 ;
37943 PyObject * obj1 = 0 ;
37944 char *kwnames[] = {
37945 (char *) "self",(char *) "n", NULL
37946 };
37947
37948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37950 if (SWIG_arg_fail(1)) SWIG_fail;
37951 {
37952 arg2 = (int)(SWIG_As_int(obj1));
37953 if (SWIG_arg_fail(2)) SWIG_fail;
37954 }
37955 {
37956 PyThreadState* __tstate = wxPyBeginAllowThreads();
37957 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37958
37959 wxPyEndAllowThreads(__tstate);
37960 if (PyErr_Occurred()) SWIG_fail;
37961 }
37962 {
37963 #if wxUSE_UNICODE
37964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37965 #else
37966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37967 #endif
37968 }
37969 return resultobj;
37970 fail:
37971 return NULL;
37972 }
37973
37974
37975 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37976 PyObject *resultobj;
37977 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37978 wxArrayString result;
37979 PyObject * obj0 = 0 ;
37980 char *kwnames[] = {
37981 (char *) "self", NULL
37982 };
37983
37984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37986 if (SWIG_arg_fail(1)) SWIG_fail;
37987 {
37988 PyThreadState* __tstate = wxPyBeginAllowThreads();
37989 result = ((wxItemContainer const *)arg1)->GetStrings();
37990
37991 wxPyEndAllowThreads(__tstate);
37992 if (PyErr_Occurred()) SWIG_fail;
37993 }
37994 {
37995 resultobj = wxArrayString2PyList_helper(result);
37996 }
37997 return resultobj;
37998 fail:
37999 return NULL;
38000 }
38001
38002
38003 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38004 PyObject *resultobj;
38005 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38006 int arg2 ;
38007 wxString *arg3 = 0 ;
38008 bool temp3 = false ;
38009 PyObject * obj0 = 0 ;
38010 PyObject * obj1 = 0 ;
38011 PyObject * obj2 = 0 ;
38012 char *kwnames[] = {
38013 (char *) "self",(char *) "n",(char *) "s", NULL
38014 };
38015
38016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38018 if (SWIG_arg_fail(1)) SWIG_fail;
38019 {
38020 arg2 = (int)(SWIG_As_int(obj1));
38021 if (SWIG_arg_fail(2)) SWIG_fail;
38022 }
38023 {
38024 arg3 = wxString_in_helper(obj2);
38025 if (arg3 == NULL) SWIG_fail;
38026 temp3 = true;
38027 }
38028 {
38029 PyThreadState* __tstate = wxPyBeginAllowThreads();
38030 (arg1)->SetString(arg2,(wxString const &)*arg3);
38031
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 Py_INCREF(Py_None); resultobj = Py_None;
38036 {
38037 if (temp3)
38038 delete arg3;
38039 }
38040 return resultobj;
38041 fail:
38042 {
38043 if (temp3)
38044 delete arg3;
38045 }
38046 return NULL;
38047 }
38048
38049
38050 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38051 PyObject *resultobj;
38052 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38053 wxString *arg2 = 0 ;
38054 int result;
38055 bool temp2 = false ;
38056 PyObject * obj0 = 0 ;
38057 PyObject * obj1 = 0 ;
38058 char *kwnames[] = {
38059 (char *) "self",(char *) "s", NULL
38060 };
38061
38062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38064 if (SWIG_arg_fail(1)) SWIG_fail;
38065 {
38066 arg2 = wxString_in_helper(obj1);
38067 if (arg2 == NULL) SWIG_fail;
38068 temp2 = true;
38069 }
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38073
38074 wxPyEndAllowThreads(__tstate);
38075 if (PyErr_Occurred()) SWIG_fail;
38076 }
38077 {
38078 resultobj = SWIG_From_int((int)(result));
38079 }
38080 {
38081 if (temp2)
38082 delete arg2;
38083 }
38084 return resultobj;
38085 fail:
38086 {
38087 if (temp2)
38088 delete arg2;
38089 }
38090 return NULL;
38091 }
38092
38093
38094 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj;
38096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38097 int arg2 ;
38098 PyObject * obj0 = 0 ;
38099 PyObject * obj1 = 0 ;
38100 char *kwnames[] = {
38101 (char *) "self",(char *) "n", NULL
38102 };
38103
38104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38106 if (SWIG_arg_fail(1)) SWIG_fail;
38107 {
38108 arg2 = (int)(SWIG_As_int(obj1));
38109 if (SWIG_arg_fail(2)) SWIG_fail;
38110 }
38111 {
38112 PyThreadState* __tstate = wxPyBeginAllowThreads();
38113 (arg1)->SetSelection(arg2);
38114
38115 wxPyEndAllowThreads(__tstate);
38116 if (PyErr_Occurred()) SWIG_fail;
38117 }
38118 Py_INCREF(Py_None); resultobj = Py_None;
38119 return resultobj;
38120 fail:
38121 return NULL;
38122 }
38123
38124
38125 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38126 PyObject *resultobj;
38127 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38128 int result;
38129 PyObject * obj0 = 0 ;
38130 char *kwnames[] = {
38131 (char *) "self", NULL
38132 };
38133
38134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38136 if (SWIG_arg_fail(1)) SWIG_fail;
38137 {
38138 PyThreadState* __tstate = wxPyBeginAllowThreads();
38139 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38140
38141 wxPyEndAllowThreads(__tstate);
38142 if (PyErr_Occurred()) SWIG_fail;
38143 }
38144 {
38145 resultobj = SWIG_From_int((int)(result));
38146 }
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38154 PyObject *resultobj;
38155 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38156 wxString *arg2 = 0 ;
38157 bool result;
38158 bool temp2 = false ;
38159 PyObject * obj0 = 0 ;
38160 PyObject * obj1 = 0 ;
38161 char *kwnames[] = {
38162 (char *) "self",(char *) "s", NULL
38163 };
38164
38165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38167 if (SWIG_arg_fail(1)) SWIG_fail;
38168 {
38169 arg2 = wxString_in_helper(obj1);
38170 if (arg2 == NULL) SWIG_fail;
38171 temp2 = true;
38172 }
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38176
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 {
38181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38182 }
38183 {
38184 if (temp2)
38185 delete arg2;
38186 }
38187 return resultobj;
38188 fail:
38189 {
38190 if (temp2)
38191 delete arg2;
38192 }
38193 return NULL;
38194 }
38195
38196
38197 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38198 PyObject *resultobj;
38199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38200 wxString result;
38201 PyObject * obj0 = 0 ;
38202 char *kwnames[] = {
38203 (char *) "self", NULL
38204 };
38205
38206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38208 if (SWIG_arg_fail(1)) SWIG_fail;
38209 {
38210 PyThreadState* __tstate = wxPyBeginAllowThreads();
38211 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38212
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 #if wxUSE_UNICODE
38218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38219 #else
38220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38221 #endif
38222 }
38223 return resultobj;
38224 fail:
38225 return NULL;
38226 }
38227
38228
38229 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38230 PyObject *resultobj;
38231 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38232 int arg2 ;
38233 PyObject * obj0 = 0 ;
38234 PyObject * obj1 = 0 ;
38235 char *kwnames[] = {
38236 (char *) "self",(char *) "n", NULL
38237 };
38238
38239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38241 if (SWIG_arg_fail(1)) SWIG_fail;
38242 {
38243 arg2 = (int)(SWIG_As_int(obj1));
38244 if (SWIG_arg_fail(2)) SWIG_fail;
38245 }
38246 {
38247 PyThreadState* __tstate = wxPyBeginAllowThreads();
38248 (arg1)->Select(arg2);
38249
38250 wxPyEndAllowThreads(__tstate);
38251 if (PyErr_Occurred()) SWIG_fail;
38252 }
38253 Py_INCREF(Py_None); resultobj = Py_None;
38254 return resultobj;
38255 fail:
38256 return NULL;
38257 }
38258
38259
38260 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38261 PyObject *obj;
38262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38263 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38264 Py_INCREF(obj);
38265 return Py_BuildValue((char *)"");
38266 }
38267 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38268 PyObject *obj;
38269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38270 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38271 Py_INCREF(obj);
38272 return Py_BuildValue((char *)"");
38273 }
38274 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj;
38276 wxSizerItem *result;
38277 char *kwnames[] = {
38278 NULL
38279 };
38280
38281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 result = (wxSizerItem *)new wxSizerItem();
38285
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxWindow *arg1 = (wxWindow *) 0 ;
38299 int arg2 ;
38300 int arg3 ;
38301 int arg4 ;
38302 PyObject *arg5 = (PyObject *) NULL ;
38303 wxSizerItem *result;
38304 PyObject * obj0 = 0 ;
38305 PyObject * obj1 = 0 ;
38306 PyObject * obj2 = 0 ;
38307 PyObject * obj3 = 0 ;
38308 PyObject * obj4 = 0 ;
38309 char *kwnames[] = {
38310 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38311 };
38312
38313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38315 if (SWIG_arg_fail(1)) SWIG_fail;
38316 {
38317 arg2 = (int)(SWIG_As_int(obj1));
38318 if (SWIG_arg_fail(2)) SWIG_fail;
38319 }
38320 {
38321 arg3 = (int)(SWIG_As_int(obj2));
38322 if (SWIG_arg_fail(3)) SWIG_fail;
38323 }
38324 {
38325 arg4 = (int)(SWIG_As_int(obj3));
38326 if (SWIG_arg_fail(4)) SWIG_fail;
38327 }
38328 if (obj4) {
38329 arg5 = obj4;
38330 }
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38334
38335 wxPyEndAllowThreads(__tstate);
38336 if (PyErr_Occurred()) SWIG_fail;
38337 }
38338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj;
38347 int arg1 ;
38348 int arg2 ;
38349 int arg3 ;
38350 int arg4 ;
38351 int arg5 ;
38352 PyObject *arg6 = (PyObject *) NULL ;
38353 wxSizerItem *result;
38354 PyObject * obj0 = 0 ;
38355 PyObject * obj1 = 0 ;
38356 PyObject * obj2 = 0 ;
38357 PyObject * obj3 = 0 ;
38358 PyObject * obj4 = 0 ;
38359 PyObject * obj5 = 0 ;
38360 char *kwnames[] = {
38361 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38362 };
38363
38364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38365 {
38366 arg1 = (int)(SWIG_As_int(obj0));
38367 if (SWIG_arg_fail(1)) SWIG_fail;
38368 }
38369 {
38370 arg2 = (int)(SWIG_As_int(obj1));
38371 if (SWIG_arg_fail(2)) SWIG_fail;
38372 }
38373 {
38374 arg3 = (int)(SWIG_As_int(obj2));
38375 if (SWIG_arg_fail(3)) SWIG_fail;
38376 }
38377 {
38378 arg4 = (int)(SWIG_As_int(obj3));
38379 if (SWIG_arg_fail(4)) SWIG_fail;
38380 }
38381 {
38382 arg5 = (int)(SWIG_As_int(obj4));
38383 if (SWIG_arg_fail(5)) SWIG_fail;
38384 }
38385 if (obj5) {
38386 arg6 = obj5;
38387 }
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38391
38392 wxPyEndAllowThreads(__tstate);
38393 if (PyErr_Occurred()) SWIG_fail;
38394 }
38395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38396 return resultobj;
38397 fail:
38398 return NULL;
38399 }
38400
38401
38402 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38403 PyObject *resultobj;
38404 wxSizer *arg1 = (wxSizer *) 0 ;
38405 int arg2 ;
38406 int arg3 ;
38407 int arg4 ;
38408 PyObject *arg5 = (PyObject *) NULL ;
38409 wxSizerItem *result;
38410 PyObject * obj0 = 0 ;
38411 PyObject * obj1 = 0 ;
38412 PyObject * obj2 = 0 ;
38413 PyObject * obj3 = 0 ;
38414 PyObject * obj4 = 0 ;
38415 char *kwnames[] = {
38416 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38417 };
38418
38419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38421 if (SWIG_arg_fail(1)) SWIG_fail;
38422 {
38423 arg2 = (int)(SWIG_As_int(obj1));
38424 if (SWIG_arg_fail(2)) SWIG_fail;
38425 }
38426 {
38427 arg3 = (int)(SWIG_As_int(obj2));
38428 if (SWIG_arg_fail(3)) SWIG_fail;
38429 }
38430 {
38431 arg4 = (int)(SWIG_As_int(obj3));
38432 if (SWIG_arg_fail(4)) SWIG_fail;
38433 }
38434 if (obj4) {
38435 arg5 = obj4;
38436 }
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38440
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38445 return resultobj;
38446 fail:
38447 return NULL;
38448 }
38449
38450
38451 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38452 PyObject *resultobj;
38453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38454 PyObject * obj0 = 0 ;
38455 char *kwnames[] = {
38456 (char *) "self", NULL
38457 };
38458
38459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38461 if (SWIG_arg_fail(1)) SWIG_fail;
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 (arg1)->DeleteWindows();
38465
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 Py_INCREF(Py_None); resultobj = Py_None;
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38477 PyObject *resultobj;
38478 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38479 PyObject * obj0 = 0 ;
38480 char *kwnames[] = {
38481 (char *) "self", NULL
38482 };
38483
38484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38486 if (SWIG_arg_fail(1)) SWIG_fail;
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 (arg1)->DetachSizer();
38490
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 Py_INCREF(Py_None); resultobj = Py_None;
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj;
38503 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38504 wxSize result;
38505 PyObject * obj0 = 0 ;
38506 char *kwnames[] = {
38507 (char *) "self", NULL
38508 };
38509
38510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38512 if (SWIG_arg_fail(1)) SWIG_fail;
38513 {
38514 PyThreadState* __tstate = wxPyBeginAllowThreads();
38515 result = (arg1)->GetSize();
38516
38517 wxPyEndAllowThreads(__tstate);
38518 if (PyErr_Occurred()) SWIG_fail;
38519 }
38520 {
38521 wxSize * resultptr;
38522 resultptr = new wxSize((wxSize &)(result));
38523 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38524 }
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj;
38533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38534 wxSize result;
38535 PyObject * obj0 = 0 ;
38536 char *kwnames[] = {
38537 (char *) "self", NULL
38538 };
38539
38540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38542 if (SWIG_arg_fail(1)) SWIG_fail;
38543 {
38544 PyThreadState* __tstate = wxPyBeginAllowThreads();
38545 result = (arg1)->CalcMin();
38546
38547 wxPyEndAllowThreads(__tstate);
38548 if (PyErr_Occurred()) SWIG_fail;
38549 }
38550 {
38551 wxSize * resultptr;
38552 resultptr = new wxSize((wxSize &)(result));
38553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38554 }
38555 return resultobj;
38556 fail:
38557 return NULL;
38558 }
38559
38560
38561 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38562 PyObject *resultobj;
38563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38564 wxPoint arg2 ;
38565 wxSize arg3 ;
38566 PyObject * obj0 = 0 ;
38567 PyObject * obj1 = 0 ;
38568 PyObject * obj2 = 0 ;
38569 char *kwnames[] = {
38570 (char *) "self",(char *) "pos",(char *) "size", NULL
38571 };
38572
38573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38575 if (SWIG_arg_fail(1)) SWIG_fail;
38576 {
38577 wxPoint * argp;
38578 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38579 if (SWIG_arg_fail(2)) SWIG_fail;
38580 if (argp == NULL) {
38581 SWIG_null_ref("wxPoint");
38582 }
38583 if (SWIG_arg_fail(2)) SWIG_fail;
38584 arg2 = *argp;
38585 }
38586 {
38587 wxSize * argp;
38588 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38589 if (SWIG_arg_fail(3)) SWIG_fail;
38590 if (argp == NULL) {
38591 SWIG_null_ref("wxSize");
38592 }
38593 if (SWIG_arg_fail(3)) SWIG_fail;
38594 arg3 = *argp;
38595 }
38596 {
38597 PyThreadState* __tstate = wxPyBeginAllowThreads();
38598 (arg1)->SetDimension(arg2,arg3);
38599
38600 wxPyEndAllowThreads(__tstate);
38601 if (PyErr_Occurred()) SWIG_fail;
38602 }
38603 Py_INCREF(Py_None); resultobj = Py_None;
38604 return resultobj;
38605 fail:
38606 return NULL;
38607 }
38608
38609
38610 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38611 PyObject *resultobj;
38612 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38613 wxSize result;
38614 PyObject * obj0 = 0 ;
38615 char *kwnames[] = {
38616 (char *) "self", NULL
38617 };
38618
38619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38621 if (SWIG_arg_fail(1)) SWIG_fail;
38622 {
38623 PyThreadState* __tstate = wxPyBeginAllowThreads();
38624 result = (arg1)->GetMinSize();
38625
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 wxSize * resultptr;
38631 resultptr = new wxSize((wxSize &)(result));
38632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38633 }
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj;
38642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38643 wxSize result;
38644 PyObject * obj0 = 0 ;
38645 char *kwnames[] = {
38646 (char *) "self", NULL
38647 };
38648
38649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38651 if (SWIG_arg_fail(1)) SWIG_fail;
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38655
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 {
38660 wxSize * resultptr;
38661 resultptr = new wxSize((wxSize &)(result));
38662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38663 }
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38671 PyObject *resultobj;
38672 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38673 int arg2 ;
38674 int arg3 ;
38675 PyObject * obj0 = 0 ;
38676 PyObject * obj1 = 0 ;
38677 PyObject * obj2 = 0 ;
38678 char *kwnames[] = {
38679 (char *) "self",(char *) "x",(char *) "y", NULL
38680 };
38681
38682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38684 if (SWIG_arg_fail(1)) SWIG_fail;
38685 {
38686 arg2 = (int)(SWIG_As_int(obj1));
38687 if (SWIG_arg_fail(2)) SWIG_fail;
38688 }
38689 {
38690 arg3 = (int)(SWIG_As_int(obj2));
38691 if (SWIG_arg_fail(3)) SWIG_fail;
38692 }
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 (arg1)->SetInitSize(arg2,arg3);
38696
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 Py_INCREF(Py_None); resultobj = Py_None;
38701 return resultobj;
38702 fail:
38703 return NULL;
38704 }
38705
38706
38707 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38708 PyObject *resultobj;
38709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38710 int arg2 ;
38711 int arg3 ;
38712 PyObject * obj0 = 0 ;
38713 PyObject * obj1 = 0 ;
38714 PyObject * obj2 = 0 ;
38715 char *kwnames[] = {
38716 (char *) "self",(char *) "width",(char *) "height", NULL
38717 };
38718
38719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38721 if (SWIG_arg_fail(1)) SWIG_fail;
38722 {
38723 arg2 = (int)(SWIG_As_int(obj1));
38724 if (SWIG_arg_fail(2)) SWIG_fail;
38725 }
38726 {
38727 arg3 = (int)(SWIG_As_int(obj2));
38728 if (SWIG_arg_fail(3)) SWIG_fail;
38729 }
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 (arg1)->SetRatio(arg2,arg3);
38733
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 Py_INCREF(Py_None); resultobj = Py_None;
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj;
38746 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38747 wxSize *arg2 = 0 ;
38748 wxSize temp2 ;
38749 PyObject * obj0 = 0 ;
38750 PyObject * obj1 = 0 ;
38751 char *kwnames[] = {
38752 (char *) "self",(char *) "size", NULL
38753 };
38754
38755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38757 if (SWIG_arg_fail(1)) SWIG_fail;
38758 {
38759 arg2 = &temp2;
38760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38761 }
38762 {
38763 PyThreadState* __tstate = wxPyBeginAllowThreads();
38764 (arg1)->SetRatio((wxSize const &)*arg2);
38765
38766 wxPyEndAllowThreads(__tstate);
38767 if (PyErr_Occurred()) SWIG_fail;
38768 }
38769 Py_INCREF(Py_None); resultobj = Py_None;
38770 return resultobj;
38771 fail:
38772 return NULL;
38773 }
38774
38775
38776 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38777 PyObject *resultobj;
38778 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38779 float arg2 ;
38780 PyObject * obj0 = 0 ;
38781 PyObject * obj1 = 0 ;
38782 char *kwnames[] = {
38783 (char *) "self",(char *) "ratio", NULL
38784 };
38785
38786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38788 if (SWIG_arg_fail(1)) SWIG_fail;
38789 {
38790 arg2 = (float)(SWIG_As_float(obj1));
38791 if (SWIG_arg_fail(2)) SWIG_fail;
38792 }
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 (arg1)->SetRatio(arg2);
38796
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 Py_INCREF(Py_None); resultobj = Py_None;
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38808 PyObject *resultobj;
38809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38810 float result;
38811 PyObject * obj0 = 0 ;
38812 char *kwnames[] = {
38813 (char *) "self", NULL
38814 };
38815
38816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38818 if (SWIG_arg_fail(1)) SWIG_fail;
38819 {
38820 PyThreadState* __tstate = wxPyBeginAllowThreads();
38821 result = (float)(arg1)->GetRatio();
38822
38823 wxPyEndAllowThreads(__tstate);
38824 if (PyErr_Occurred()) SWIG_fail;
38825 }
38826 {
38827 resultobj = SWIG_From_float((float)(result));
38828 }
38829 return resultobj;
38830 fail:
38831 return NULL;
38832 }
38833
38834
38835 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38836 PyObject *resultobj;
38837 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38838 wxRect result;
38839 PyObject * obj0 = 0 ;
38840 char *kwnames[] = {
38841 (char *) "self", NULL
38842 };
38843
38844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38846 if (SWIG_arg_fail(1)) SWIG_fail;
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 result = (arg1)->GetRect();
38850
38851 wxPyEndAllowThreads(__tstate);
38852 if (PyErr_Occurred()) SWIG_fail;
38853 }
38854 {
38855 wxRect * resultptr;
38856 resultptr = new wxRect((wxRect &)(result));
38857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38858 }
38859 return resultobj;
38860 fail:
38861 return NULL;
38862 }
38863
38864
38865 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38866 PyObject *resultobj;
38867 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38868 bool result;
38869 PyObject * obj0 = 0 ;
38870 char *kwnames[] = {
38871 (char *) "self", NULL
38872 };
38873
38874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38876 if (SWIG_arg_fail(1)) SWIG_fail;
38877 {
38878 PyThreadState* __tstate = wxPyBeginAllowThreads();
38879 result = (bool)(arg1)->IsWindow();
38880
38881 wxPyEndAllowThreads(__tstate);
38882 if (PyErr_Occurred()) SWIG_fail;
38883 }
38884 {
38885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38886 }
38887 return resultobj;
38888 fail:
38889 return NULL;
38890 }
38891
38892
38893 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38894 PyObject *resultobj;
38895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38896 bool result;
38897 PyObject * obj0 = 0 ;
38898 char *kwnames[] = {
38899 (char *) "self", NULL
38900 };
38901
38902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38904 if (SWIG_arg_fail(1)) SWIG_fail;
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 result = (bool)(arg1)->IsSizer();
38908
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 {
38913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38914 }
38915 return resultobj;
38916 fail:
38917 return NULL;
38918 }
38919
38920
38921 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj;
38923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38924 bool result;
38925 PyObject * obj0 = 0 ;
38926 char *kwnames[] = {
38927 (char *) "self", NULL
38928 };
38929
38930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38932 if (SWIG_arg_fail(1)) SWIG_fail;
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 result = (bool)(arg1)->IsSpacer();
38936
38937 wxPyEndAllowThreads(__tstate);
38938 if (PyErr_Occurred()) SWIG_fail;
38939 }
38940 {
38941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38942 }
38943 return resultobj;
38944 fail:
38945 return NULL;
38946 }
38947
38948
38949 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38950 PyObject *resultobj;
38951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38952 int arg2 ;
38953 PyObject * obj0 = 0 ;
38954 PyObject * obj1 = 0 ;
38955 char *kwnames[] = {
38956 (char *) "self",(char *) "proportion", NULL
38957 };
38958
38959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38961 if (SWIG_arg_fail(1)) SWIG_fail;
38962 {
38963 arg2 = (int)(SWIG_As_int(obj1));
38964 if (SWIG_arg_fail(2)) SWIG_fail;
38965 }
38966 {
38967 PyThreadState* __tstate = wxPyBeginAllowThreads();
38968 (arg1)->SetProportion(arg2);
38969
38970 wxPyEndAllowThreads(__tstate);
38971 if (PyErr_Occurred()) SWIG_fail;
38972 }
38973 Py_INCREF(Py_None); resultobj = Py_None;
38974 return resultobj;
38975 fail:
38976 return NULL;
38977 }
38978
38979
38980 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38981 PyObject *resultobj;
38982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38983 int result;
38984 PyObject * obj0 = 0 ;
38985 char *kwnames[] = {
38986 (char *) "self", NULL
38987 };
38988
38989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38991 if (SWIG_arg_fail(1)) SWIG_fail;
38992 {
38993 PyThreadState* __tstate = wxPyBeginAllowThreads();
38994 result = (int)(arg1)->GetProportion();
38995
38996 wxPyEndAllowThreads(__tstate);
38997 if (PyErr_Occurred()) SWIG_fail;
38998 }
38999 {
39000 resultobj = SWIG_From_int((int)(result));
39001 }
39002 return resultobj;
39003 fail:
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj;
39010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39011 int arg2 ;
39012 PyObject * obj0 = 0 ;
39013 PyObject * obj1 = 0 ;
39014 char *kwnames[] = {
39015 (char *) "self",(char *) "flag", NULL
39016 };
39017
39018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39020 if (SWIG_arg_fail(1)) SWIG_fail;
39021 {
39022 arg2 = (int)(SWIG_As_int(obj1));
39023 if (SWIG_arg_fail(2)) SWIG_fail;
39024 }
39025 {
39026 PyThreadState* __tstate = wxPyBeginAllowThreads();
39027 (arg1)->SetFlag(arg2);
39028
39029 wxPyEndAllowThreads(__tstate);
39030 if (PyErr_Occurred()) SWIG_fail;
39031 }
39032 Py_INCREF(Py_None); resultobj = Py_None;
39033 return resultobj;
39034 fail:
39035 return NULL;
39036 }
39037
39038
39039 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39040 PyObject *resultobj;
39041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39042 int result;
39043 PyObject * obj0 = 0 ;
39044 char *kwnames[] = {
39045 (char *) "self", NULL
39046 };
39047
39048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39050 if (SWIG_arg_fail(1)) SWIG_fail;
39051 {
39052 PyThreadState* __tstate = wxPyBeginAllowThreads();
39053 result = (int)(arg1)->GetFlag();
39054
39055 wxPyEndAllowThreads(__tstate);
39056 if (PyErr_Occurred()) SWIG_fail;
39057 }
39058 {
39059 resultobj = SWIG_From_int((int)(result));
39060 }
39061 return resultobj;
39062 fail:
39063 return NULL;
39064 }
39065
39066
39067 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39068 PyObject *resultobj;
39069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39070 int arg2 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 char *kwnames[] = {
39074 (char *) "self",(char *) "border", NULL
39075 };
39076
39077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39079 if (SWIG_arg_fail(1)) SWIG_fail;
39080 {
39081 arg2 = (int)(SWIG_As_int(obj1));
39082 if (SWIG_arg_fail(2)) SWIG_fail;
39083 }
39084 {
39085 PyThreadState* __tstate = wxPyBeginAllowThreads();
39086 (arg1)->SetBorder(arg2);
39087
39088 wxPyEndAllowThreads(__tstate);
39089 if (PyErr_Occurred()) SWIG_fail;
39090 }
39091 Py_INCREF(Py_None); resultobj = Py_None;
39092 return resultobj;
39093 fail:
39094 return NULL;
39095 }
39096
39097
39098 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39099 PyObject *resultobj;
39100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39101 int result;
39102 PyObject * obj0 = 0 ;
39103 char *kwnames[] = {
39104 (char *) "self", NULL
39105 };
39106
39107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39109 if (SWIG_arg_fail(1)) SWIG_fail;
39110 {
39111 PyThreadState* __tstate = wxPyBeginAllowThreads();
39112 result = (int)(arg1)->GetBorder();
39113
39114 wxPyEndAllowThreads(__tstate);
39115 if (PyErr_Occurred()) SWIG_fail;
39116 }
39117 {
39118 resultobj = SWIG_From_int((int)(result));
39119 }
39120 return resultobj;
39121 fail:
39122 return NULL;
39123 }
39124
39125
39126 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39127 PyObject *resultobj;
39128 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39129 wxWindow *result;
39130 PyObject * obj0 = 0 ;
39131 char *kwnames[] = {
39132 (char *) "self", NULL
39133 };
39134
39135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39137 if (SWIG_arg_fail(1)) SWIG_fail;
39138 {
39139 PyThreadState* __tstate = wxPyBeginAllowThreads();
39140 result = (wxWindow *)(arg1)->GetWindow();
39141
39142 wxPyEndAllowThreads(__tstate);
39143 if (PyErr_Occurred()) SWIG_fail;
39144 }
39145 {
39146 resultobj = wxPyMake_wxObject(result, 0);
39147 }
39148 return resultobj;
39149 fail:
39150 return NULL;
39151 }
39152
39153
39154 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39155 PyObject *resultobj;
39156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39157 wxWindow *arg2 = (wxWindow *) 0 ;
39158 PyObject * obj0 = 0 ;
39159 PyObject * obj1 = 0 ;
39160 char *kwnames[] = {
39161 (char *) "self",(char *) "window", NULL
39162 };
39163
39164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39166 if (SWIG_arg_fail(1)) SWIG_fail;
39167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39168 if (SWIG_arg_fail(2)) SWIG_fail;
39169 {
39170 PyThreadState* __tstate = wxPyBeginAllowThreads();
39171 (arg1)->SetWindow(arg2);
39172
39173 wxPyEndAllowThreads(__tstate);
39174 if (PyErr_Occurred()) SWIG_fail;
39175 }
39176 Py_INCREF(Py_None); resultobj = Py_None;
39177 return resultobj;
39178 fail:
39179 return NULL;
39180 }
39181
39182
39183 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39184 PyObject *resultobj;
39185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39186 wxSizer *result;
39187 PyObject * obj0 = 0 ;
39188 char *kwnames[] = {
39189 (char *) "self", NULL
39190 };
39191
39192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39194 if (SWIG_arg_fail(1)) SWIG_fail;
39195 {
39196 PyThreadState* __tstate = wxPyBeginAllowThreads();
39197 result = (wxSizer *)(arg1)->GetSizer();
39198
39199 wxPyEndAllowThreads(__tstate);
39200 if (PyErr_Occurred()) SWIG_fail;
39201 }
39202 {
39203 resultobj = wxPyMake_wxSizer(result, 0);
39204 }
39205 return resultobj;
39206 fail:
39207 return NULL;
39208 }
39209
39210
39211 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj;
39213 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39214 wxSizer *arg2 = (wxSizer *) 0 ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 char *kwnames[] = {
39218 (char *) "self",(char *) "sizer", NULL
39219 };
39220
39221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39223 if (SWIG_arg_fail(1)) SWIG_fail;
39224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39225 if (SWIG_arg_fail(2)) SWIG_fail;
39226 {
39227 PyThreadState* __tstate = wxPyBeginAllowThreads();
39228 (arg1)->SetSizer(arg2);
39229
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 Py_INCREF(Py_None); resultobj = Py_None;
39234 return resultobj;
39235 fail:
39236 return NULL;
39237 }
39238
39239
39240 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39241 PyObject *resultobj;
39242 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39243 wxSize *result;
39244 PyObject * obj0 = 0 ;
39245 char *kwnames[] = {
39246 (char *) "self", NULL
39247 };
39248
39249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39251 if (SWIG_arg_fail(1)) SWIG_fail;
39252 {
39253 PyThreadState* __tstate = wxPyBeginAllowThreads();
39254 {
39255 wxSize const &_result_ref = (arg1)->GetSpacer();
39256 result = (wxSize *) &_result_ref;
39257 }
39258
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39272 wxSize *arg2 = 0 ;
39273 wxSize temp2 ;
39274 PyObject * obj0 = 0 ;
39275 PyObject * obj1 = 0 ;
39276 char *kwnames[] = {
39277 (char *) "self",(char *) "size", NULL
39278 };
39279
39280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39282 if (SWIG_arg_fail(1)) SWIG_fail;
39283 {
39284 arg2 = &temp2;
39285 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39286 }
39287 {
39288 PyThreadState* __tstate = wxPyBeginAllowThreads();
39289 (arg1)->SetSpacer((wxSize const &)*arg2);
39290
39291 wxPyEndAllowThreads(__tstate);
39292 if (PyErr_Occurred()) SWIG_fail;
39293 }
39294 Py_INCREF(Py_None); resultobj = Py_None;
39295 return resultobj;
39296 fail:
39297 return NULL;
39298 }
39299
39300
39301 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39302 PyObject *resultobj;
39303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39304 bool arg2 ;
39305 PyObject * obj0 = 0 ;
39306 PyObject * obj1 = 0 ;
39307 char *kwnames[] = {
39308 (char *) "self",(char *) "show", NULL
39309 };
39310
39311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39313 if (SWIG_arg_fail(1)) SWIG_fail;
39314 {
39315 arg2 = (bool)(SWIG_As_bool(obj1));
39316 if (SWIG_arg_fail(2)) SWIG_fail;
39317 }
39318 {
39319 PyThreadState* __tstate = wxPyBeginAllowThreads();
39320 (arg1)->Show(arg2);
39321
39322 wxPyEndAllowThreads(__tstate);
39323 if (PyErr_Occurred()) SWIG_fail;
39324 }
39325 Py_INCREF(Py_None); resultobj = Py_None;
39326 return resultobj;
39327 fail:
39328 return NULL;
39329 }
39330
39331
39332 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39333 PyObject *resultobj;
39334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39335 bool result;
39336 PyObject * obj0 = 0 ;
39337 char *kwnames[] = {
39338 (char *) "self", NULL
39339 };
39340
39341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39343 if (SWIG_arg_fail(1)) SWIG_fail;
39344 {
39345 PyThreadState* __tstate = wxPyBeginAllowThreads();
39346 result = (bool)(arg1)->IsShown();
39347
39348 wxPyEndAllowThreads(__tstate);
39349 if (PyErr_Occurred()) SWIG_fail;
39350 }
39351 {
39352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39353 }
39354 return resultobj;
39355 fail:
39356 return NULL;
39357 }
39358
39359
39360 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39361 PyObject *resultobj;
39362 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39363 wxPoint result;
39364 PyObject * obj0 = 0 ;
39365 char *kwnames[] = {
39366 (char *) "self", NULL
39367 };
39368
39369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39371 if (SWIG_arg_fail(1)) SWIG_fail;
39372 {
39373 PyThreadState* __tstate = wxPyBeginAllowThreads();
39374 result = (arg1)->GetPosition();
39375
39376 wxPyEndAllowThreads(__tstate);
39377 if (PyErr_Occurred()) SWIG_fail;
39378 }
39379 {
39380 wxPoint * resultptr;
39381 resultptr = new wxPoint((wxPoint &)(result));
39382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39383 }
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj;
39392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39393 PyObject *result;
39394 PyObject * obj0 = 0 ;
39395 char *kwnames[] = {
39396 (char *) "self", NULL
39397 };
39398
39399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39401 if (SWIG_arg_fail(1)) SWIG_fail;
39402 {
39403 PyThreadState* __tstate = wxPyBeginAllowThreads();
39404 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39405
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 resultobj = result;
39410 return resultobj;
39411 fail:
39412 return NULL;
39413 }
39414
39415
39416 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39417 PyObject *obj;
39418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39419 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39420 Py_INCREF(obj);
39421 return Py_BuildValue((char *)"");
39422 }
39423 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39424 PyObject *resultobj;
39425 wxSizer *arg1 = (wxSizer *) 0 ;
39426 PyObject *arg2 = (PyObject *) 0 ;
39427 PyObject * obj0 = 0 ;
39428 PyObject * obj1 = 0 ;
39429 char *kwnames[] = {
39430 (char *) "self",(char *) "_self", NULL
39431 };
39432
39433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39435 if (SWIG_arg_fail(1)) SWIG_fail;
39436 arg2 = obj1;
39437 {
39438 PyThreadState* __tstate = wxPyBeginAllowThreads();
39439 wxSizer__setOORInfo(arg1,arg2);
39440
39441 wxPyEndAllowThreads(__tstate);
39442 if (PyErr_Occurred()) SWIG_fail;
39443 }
39444 Py_INCREF(Py_None); resultobj = Py_None;
39445 return resultobj;
39446 fail:
39447 return NULL;
39448 }
39449
39450
39451 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39452 PyObject *resultobj;
39453 wxSizer *arg1 = (wxSizer *) 0 ;
39454 PyObject *arg2 = (PyObject *) 0 ;
39455 int arg3 = (int) 0 ;
39456 int arg4 = (int) 0 ;
39457 int arg5 = (int) 0 ;
39458 PyObject *arg6 = (PyObject *) NULL ;
39459 wxSizerItem *result;
39460 PyObject * obj0 = 0 ;
39461 PyObject * obj1 = 0 ;
39462 PyObject * obj2 = 0 ;
39463 PyObject * obj3 = 0 ;
39464 PyObject * obj4 = 0 ;
39465 PyObject * obj5 = 0 ;
39466 char *kwnames[] = {
39467 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39468 };
39469
39470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39472 if (SWIG_arg_fail(1)) SWIG_fail;
39473 arg2 = obj1;
39474 if (obj2) {
39475 {
39476 arg3 = (int)(SWIG_As_int(obj2));
39477 if (SWIG_arg_fail(3)) SWIG_fail;
39478 }
39479 }
39480 if (obj3) {
39481 {
39482 arg4 = (int)(SWIG_As_int(obj3));
39483 if (SWIG_arg_fail(4)) SWIG_fail;
39484 }
39485 }
39486 if (obj4) {
39487 {
39488 arg5 = (int)(SWIG_As_int(obj4));
39489 if (SWIG_arg_fail(5)) SWIG_fail;
39490 }
39491 }
39492 if (obj5) {
39493 arg6 = obj5;
39494 }
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39498
39499 wxPyEndAllowThreads(__tstate);
39500 if (PyErr_Occurred()) SWIG_fail;
39501 }
39502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39503 return resultobj;
39504 fail:
39505 return NULL;
39506 }
39507
39508
39509 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39510 PyObject *resultobj;
39511 wxSizer *arg1 = (wxSizer *) 0 ;
39512 int arg2 ;
39513 PyObject *arg3 = (PyObject *) 0 ;
39514 int arg4 = (int) 0 ;
39515 int arg5 = (int) 0 ;
39516 int arg6 = (int) 0 ;
39517 PyObject *arg7 = (PyObject *) NULL ;
39518 wxSizerItem *result;
39519 PyObject * obj0 = 0 ;
39520 PyObject * obj1 = 0 ;
39521 PyObject * obj2 = 0 ;
39522 PyObject * obj3 = 0 ;
39523 PyObject * obj4 = 0 ;
39524 PyObject * obj5 = 0 ;
39525 PyObject * obj6 = 0 ;
39526 char *kwnames[] = {
39527 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39528 };
39529
39530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39532 if (SWIG_arg_fail(1)) SWIG_fail;
39533 {
39534 arg2 = (int)(SWIG_As_int(obj1));
39535 if (SWIG_arg_fail(2)) SWIG_fail;
39536 }
39537 arg3 = obj2;
39538 if (obj3) {
39539 {
39540 arg4 = (int)(SWIG_As_int(obj3));
39541 if (SWIG_arg_fail(4)) SWIG_fail;
39542 }
39543 }
39544 if (obj4) {
39545 {
39546 arg5 = (int)(SWIG_As_int(obj4));
39547 if (SWIG_arg_fail(5)) SWIG_fail;
39548 }
39549 }
39550 if (obj5) {
39551 {
39552 arg6 = (int)(SWIG_As_int(obj5));
39553 if (SWIG_arg_fail(6)) SWIG_fail;
39554 }
39555 }
39556 if (obj6) {
39557 arg7 = obj6;
39558 }
39559 {
39560 PyThreadState* __tstate = wxPyBeginAllowThreads();
39561 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39562
39563 wxPyEndAllowThreads(__tstate);
39564 if (PyErr_Occurred()) SWIG_fail;
39565 }
39566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39567 return resultobj;
39568 fail:
39569 return NULL;
39570 }
39571
39572
39573 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39574 PyObject *resultobj;
39575 wxSizer *arg1 = (wxSizer *) 0 ;
39576 PyObject *arg2 = (PyObject *) 0 ;
39577 int arg3 = (int) 0 ;
39578 int arg4 = (int) 0 ;
39579 int arg5 = (int) 0 ;
39580 PyObject *arg6 = (PyObject *) NULL ;
39581 wxSizerItem *result;
39582 PyObject * obj0 = 0 ;
39583 PyObject * obj1 = 0 ;
39584 PyObject * obj2 = 0 ;
39585 PyObject * obj3 = 0 ;
39586 PyObject * obj4 = 0 ;
39587 PyObject * obj5 = 0 ;
39588 char *kwnames[] = {
39589 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39590 };
39591
39592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39594 if (SWIG_arg_fail(1)) SWIG_fail;
39595 arg2 = obj1;
39596 if (obj2) {
39597 {
39598 arg3 = (int)(SWIG_As_int(obj2));
39599 if (SWIG_arg_fail(3)) SWIG_fail;
39600 }
39601 }
39602 if (obj3) {
39603 {
39604 arg4 = (int)(SWIG_As_int(obj3));
39605 if (SWIG_arg_fail(4)) SWIG_fail;
39606 }
39607 }
39608 if (obj4) {
39609 {
39610 arg5 = (int)(SWIG_As_int(obj4));
39611 if (SWIG_arg_fail(5)) SWIG_fail;
39612 }
39613 }
39614 if (obj5) {
39615 arg6 = obj5;
39616 }
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39620
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj;
39633 wxSizer *arg1 = (wxSizer *) 0 ;
39634 PyObject *arg2 = (PyObject *) 0 ;
39635 bool result;
39636 PyObject * obj0 = 0 ;
39637 PyObject * obj1 = 0 ;
39638 char *kwnames[] = {
39639 (char *) "self",(char *) "item", NULL
39640 };
39641
39642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39644 if (SWIG_arg_fail(1)) SWIG_fail;
39645 arg2 = obj1;
39646 {
39647 PyThreadState* __tstate = wxPyBeginAllowThreads();
39648 result = (bool)wxSizer_Remove(arg1,arg2);
39649
39650 wxPyEndAllowThreads(__tstate);
39651 if (PyErr_Occurred()) SWIG_fail;
39652 }
39653 {
39654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39655 }
39656 return resultobj;
39657 fail:
39658 return NULL;
39659 }
39660
39661
39662 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj;
39664 wxSizer *arg1 = (wxSizer *) 0 ;
39665 PyObject *arg2 = (PyObject *) 0 ;
39666 bool result;
39667 PyObject * obj0 = 0 ;
39668 PyObject * obj1 = 0 ;
39669 char *kwnames[] = {
39670 (char *) "self",(char *) "item", NULL
39671 };
39672
39673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39675 if (SWIG_arg_fail(1)) SWIG_fail;
39676 arg2 = obj1;
39677 {
39678 PyThreadState* __tstate = wxPyBeginAllowThreads();
39679 result = (bool)wxSizer_Detach(arg1,arg2);
39680
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 {
39685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39686 }
39687 return resultobj;
39688 fail:
39689 return NULL;
39690 }
39691
39692
39693 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39694 PyObject *resultobj;
39695 wxSizer *arg1 = (wxSizer *) 0 ;
39696 PyObject *arg2 = (PyObject *) 0 ;
39697 wxSizerItem *result;
39698 PyObject * obj0 = 0 ;
39699 PyObject * obj1 = 0 ;
39700 char *kwnames[] = {
39701 (char *) "self",(char *) "item", NULL
39702 };
39703
39704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39706 if (SWIG_arg_fail(1)) SWIG_fail;
39707 arg2 = obj1;
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39711
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj;
39724 wxSizer *arg1 = (wxSizer *) 0 ;
39725 PyObject *arg2 = (PyObject *) 0 ;
39726 wxSize *arg3 = 0 ;
39727 wxSize temp3 ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 PyObject * obj2 = 0 ;
39731 char *kwnames[] = {
39732 (char *) "self",(char *) "item",(char *) "size", NULL
39733 };
39734
39735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 arg2 = obj1;
39739 {
39740 arg3 = &temp3;
39741 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39742 }
39743 {
39744 PyThreadState* __tstate = wxPyBeginAllowThreads();
39745 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39746
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 Py_INCREF(Py_None); resultobj = Py_None;
39751 return resultobj;
39752 fail:
39753 return NULL;
39754 }
39755
39756
39757 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39758 PyObject *resultobj;
39759 wxSizer *arg1 = (wxSizer *) 0 ;
39760 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39761 wxSizerItem *result;
39762 PyObject * obj0 = 0 ;
39763 PyObject * obj1 = 0 ;
39764 char *kwnames[] = {
39765 (char *) "self",(char *) "item", NULL
39766 };
39767
39768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39770 if (SWIG_arg_fail(1)) SWIG_fail;
39771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39772 if (SWIG_arg_fail(2)) SWIG_fail;
39773 {
39774 PyThreadState* __tstate = wxPyBeginAllowThreads();
39775 result = (wxSizerItem *)(arg1)->Add(arg2);
39776
39777 wxPyEndAllowThreads(__tstate);
39778 if (PyErr_Occurred()) SWIG_fail;
39779 }
39780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39781 return resultobj;
39782 fail:
39783 return NULL;
39784 }
39785
39786
39787 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39788 PyObject *resultobj;
39789 wxSizer *arg1 = (wxSizer *) 0 ;
39790 size_t arg2 ;
39791 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39792 wxSizerItem *result;
39793 PyObject * obj0 = 0 ;
39794 PyObject * obj1 = 0 ;
39795 PyObject * obj2 = 0 ;
39796 char *kwnames[] = {
39797 (char *) "self",(char *) "index",(char *) "item", NULL
39798 };
39799
39800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39802 if (SWIG_arg_fail(1)) SWIG_fail;
39803 {
39804 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39805 if (SWIG_arg_fail(2)) SWIG_fail;
39806 }
39807 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39808 if (SWIG_arg_fail(3)) SWIG_fail;
39809 {
39810 PyThreadState* __tstate = wxPyBeginAllowThreads();
39811 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39812
39813 wxPyEndAllowThreads(__tstate);
39814 if (PyErr_Occurred()) SWIG_fail;
39815 }
39816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39817 return resultobj;
39818 fail:
39819 return NULL;
39820 }
39821
39822
39823 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39824 PyObject *resultobj;
39825 wxSizer *arg1 = (wxSizer *) 0 ;
39826 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39827 wxSizerItem *result;
39828 PyObject * obj0 = 0 ;
39829 PyObject * obj1 = 0 ;
39830 char *kwnames[] = {
39831 (char *) "self",(char *) "item", NULL
39832 };
39833
39834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39836 if (SWIG_arg_fail(1)) SWIG_fail;
39837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39838 if (SWIG_arg_fail(2)) SWIG_fail;
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj;
39855 wxSizer *arg1 = (wxSizer *) 0 ;
39856 int arg2 ;
39857 int arg3 ;
39858 int arg4 ;
39859 int arg5 ;
39860 PyObject * obj0 = 0 ;
39861 PyObject * obj1 = 0 ;
39862 PyObject * obj2 = 0 ;
39863 PyObject * obj3 = 0 ;
39864 PyObject * obj4 = 0 ;
39865 char *kwnames[] = {
39866 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39867 };
39868
39869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39871 if (SWIG_arg_fail(1)) SWIG_fail;
39872 {
39873 arg2 = (int)(SWIG_As_int(obj1));
39874 if (SWIG_arg_fail(2)) SWIG_fail;
39875 }
39876 {
39877 arg3 = (int)(SWIG_As_int(obj2));
39878 if (SWIG_arg_fail(3)) SWIG_fail;
39879 }
39880 {
39881 arg4 = (int)(SWIG_As_int(obj3));
39882 if (SWIG_arg_fail(4)) SWIG_fail;
39883 }
39884 {
39885 arg5 = (int)(SWIG_As_int(obj4));
39886 if (SWIG_arg_fail(5)) SWIG_fail;
39887 }
39888 {
39889 PyThreadState* __tstate = wxPyBeginAllowThreads();
39890 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39891
39892 wxPyEndAllowThreads(__tstate);
39893 if (PyErr_Occurred()) SWIG_fail;
39894 }
39895 Py_INCREF(Py_None); resultobj = Py_None;
39896 return resultobj;
39897 fail:
39898 return NULL;
39899 }
39900
39901
39902 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39903 PyObject *resultobj;
39904 wxSizer *arg1 = (wxSizer *) 0 ;
39905 wxSize *arg2 = 0 ;
39906 wxSize temp2 ;
39907 PyObject * obj0 = 0 ;
39908 PyObject * obj1 = 0 ;
39909 char *kwnames[] = {
39910 (char *) "self",(char *) "size", NULL
39911 };
39912
39913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39915 if (SWIG_arg_fail(1)) SWIG_fail;
39916 {
39917 arg2 = &temp2;
39918 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39919 }
39920 {
39921 PyThreadState* __tstate = wxPyBeginAllowThreads();
39922 (arg1)->SetMinSize((wxSize const &)*arg2);
39923
39924 wxPyEndAllowThreads(__tstate);
39925 if (PyErr_Occurred()) SWIG_fail;
39926 }
39927 Py_INCREF(Py_None); resultobj = Py_None;
39928 return resultobj;
39929 fail:
39930 return NULL;
39931 }
39932
39933
39934 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39935 PyObject *resultobj;
39936 wxSizer *arg1 = (wxSizer *) 0 ;
39937 wxSize result;
39938 PyObject * obj0 = 0 ;
39939 char *kwnames[] = {
39940 (char *) "self", NULL
39941 };
39942
39943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39945 if (SWIG_arg_fail(1)) SWIG_fail;
39946 {
39947 PyThreadState* __tstate = wxPyBeginAllowThreads();
39948 result = (arg1)->GetSize();
39949
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 {
39954 wxSize * resultptr;
39955 resultptr = new wxSize((wxSize &)(result));
39956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39957 }
39958 return resultobj;
39959 fail:
39960 return NULL;
39961 }
39962
39963
39964 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39965 PyObject *resultobj;
39966 wxSizer *arg1 = (wxSizer *) 0 ;
39967 wxPoint result;
39968 PyObject * obj0 = 0 ;
39969 char *kwnames[] = {
39970 (char *) "self", NULL
39971 };
39972
39973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39975 if (SWIG_arg_fail(1)) SWIG_fail;
39976 {
39977 PyThreadState* __tstate = wxPyBeginAllowThreads();
39978 result = (arg1)->GetPosition();
39979
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 {
39984 wxPoint * resultptr;
39985 resultptr = new wxPoint((wxPoint &)(result));
39986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39987 }
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj;
39996 wxSizer *arg1 = (wxSizer *) 0 ;
39997 wxSize result;
39998 PyObject * obj0 = 0 ;
39999 char *kwnames[] = {
40000 (char *) "self", NULL
40001 };
40002
40003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40005 if (SWIG_arg_fail(1)) SWIG_fail;
40006 {
40007 PyThreadState* __tstate = wxPyBeginAllowThreads();
40008 result = (arg1)->GetMinSize();
40009
40010 wxPyEndAllowThreads(__tstate);
40011 if (PyErr_Occurred()) SWIG_fail;
40012 }
40013 {
40014 wxSize * resultptr;
40015 resultptr = new wxSize((wxSize &)(result));
40016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40017 }
40018 return resultobj;
40019 fail:
40020 return NULL;
40021 }
40022
40023
40024 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40025 PyObject *resultobj;
40026 wxSizer *arg1 = (wxSizer *) 0 ;
40027 PyObject * obj0 = 0 ;
40028 char *kwnames[] = {
40029 (char *) "self", NULL
40030 };
40031
40032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40034 if (SWIG_arg_fail(1)) SWIG_fail;
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 (arg1)->RecalcSizes();
40038
40039 wxPyEndAllowThreads(__tstate);
40040 if (PyErr_Occurred()) SWIG_fail;
40041 }
40042 Py_INCREF(Py_None); resultobj = Py_None;
40043 return resultobj;
40044 fail:
40045 return NULL;
40046 }
40047
40048
40049 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40050 PyObject *resultobj;
40051 wxSizer *arg1 = (wxSizer *) 0 ;
40052 wxSize result;
40053 PyObject * obj0 = 0 ;
40054 char *kwnames[] = {
40055 (char *) "self", NULL
40056 };
40057
40058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40060 if (SWIG_arg_fail(1)) SWIG_fail;
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = (arg1)->CalcMin();
40064
40065 wxPyEndAllowThreads(__tstate);
40066 if (PyErr_Occurred()) SWIG_fail;
40067 }
40068 {
40069 wxSize * resultptr;
40070 resultptr = new wxSize((wxSize &)(result));
40071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40072 }
40073 return resultobj;
40074 fail:
40075 return NULL;
40076 }
40077
40078
40079 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40080 PyObject *resultobj;
40081 wxSizer *arg1 = (wxSizer *) 0 ;
40082 PyObject * obj0 = 0 ;
40083 char *kwnames[] = {
40084 (char *) "self", NULL
40085 };
40086
40087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40089 if (SWIG_arg_fail(1)) SWIG_fail;
40090 {
40091 PyThreadState* __tstate = wxPyBeginAllowThreads();
40092 (arg1)->Layout();
40093
40094 wxPyEndAllowThreads(__tstate);
40095 if (PyErr_Occurred()) SWIG_fail;
40096 }
40097 Py_INCREF(Py_None); resultobj = Py_None;
40098 return resultobj;
40099 fail:
40100 return NULL;
40101 }
40102
40103
40104 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40105 PyObject *resultobj;
40106 wxSizer *arg1 = (wxSizer *) 0 ;
40107 wxWindow *arg2 = (wxWindow *) 0 ;
40108 wxSize result;
40109 PyObject * obj0 = 0 ;
40110 PyObject * obj1 = 0 ;
40111 char *kwnames[] = {
40112 (char *) "self",(char *) "window", NULL
40113 };
40114
40115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40117 if (SWIG_arg_fail(1)) SWIG_fail;
40118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40119 if (SWIG_arg_fail(2)) SWIG_fail;
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 result = (arg1)->Fit(arg2);
40123
40124 wxPyEndAllowThreads(__tstate);
40125 if (PyErr_Occurred()) SWIG_fail;
40126 }
40127 {
40128 wxSize * resultptr;
40129 resultptr = new wxSize((wxSize &)(result));
40130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40131 }
40132 return resultobj;
40133 fail:
40134 return NULL;
40135 }
40136
40137
40138 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40139 PyObject *resultobj;
40140 wxSizer *arg1 = (wxSizer *) 0 ;
40141 wxWindow *arg2 = (wxWindow *) 0 ;
40142 PyObject * obj0 = 0 ;
40143 PyObject * obj1 = 0 ;
40144 char *kwnames[] = {
40145 (char *) "self",(char *) "window", NULL
40146 };
40147
40148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40150 if (SWIG_arg_fail(1)) SWIG_fail;
40151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40152 if (SWIG_arg_fail(2)) SWIG_fail;
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 (arg1)->FitInside(arg2);
40156
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 Py_INCREF(Py_None); resultobj = Py_None;
40161 return resultobj;
40162 fail:
40163 return NULL;
40164 }
40165
40166
40167 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40168 PyObject *resultobj;
40169 wxSizer *arg1 = (wxSizer *) 0 ;
40170 wxWindow *arg2 = (wxWindow *) 0 ;
40171 PyObject * obj0 = 0 ;
40172 PyObject * obj1 = 0 ;
40173 char *kwnames[] = {
40174 (char *) "self",(char *) "window", NULL
40175 };
40176
40177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40179 if (SWIG_arg_fail(1)) SWIG_fail;
40180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40181 if (SWIG_arg_fail(2)) SWIG_fail;
40182 {
40183 PyThreadState* __tstate = wxPyBeginAllowThreads();
40184 (arg1)->SetSizeHints(arg2);
40185
40186 wxPyEndAllowThreads(__tstate);
40187 if (PyErr_Occurred()) SWIG_fail;
40188 }
40189 Py_INCREF(Py_None); resultobj = Py_None;
40190 return resultobj;
40191 fail:
40192 return NULL;
40193 }
40194
40195
40196 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40197 PyObject *resultobj;
40198 wxSizer *arg1 = (wxSizer *) 0 ;
40199 wxWindow *arg2 = (wxWindow *) 0 ;
40200 PyObject * obj0 = 0 ;
40201 PyObject * obj1 = 0 ;
40202 char *kwnames[] = {
40203 (char *) "self",(char *) "window", NULL
40204 };
40205
40206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40208 if (SWIG_arg_fail(1)) SWIG_fail;
40209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40210 if (SWIG_arg_fail(2)) SWIG_fail;
40211 {
40212 PyThreadState* __tstate = wxPyBeginAllowThreads();
40213 (arg1)->SetVirtualSizeHints(arg2);
40214
40215 wxPyEndAllowThreads(__tstate);
40216 if (PyErr_Occurred()) SWIG_fail;
40217 }
40218 Py_INCREF(Py_None); resultobj = Py_None;
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40226 PyObject *resultobj;
40227 wxSizer *arg1 = (wxSizer *) 0 ;
40228 bool arg2 = (bool) false ;
40229 PyObject * obj0 = 0 ;
40230 PyObject * obj1 = 0 ;
40231 char *kwnames[] = {
40232 (char *) "self",(char *) "deleteWindows", NULL
40233 };
40234
40235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40237 if (SWIG_arg_fail(1)) SWIG_fail;
40238 if (obj1) {
40239 {
40240 arg2 = (bool)(SWIG_As_bool(obj1));
40241 if (SWIG_arg_fail(2)) SWIG_fail;
40242 }
40243 }
40244 {
40245 PyThreadState* __tstate = wxPyBeginAllowThreads();
40246 (arg1)->Clear(arg2);
40247
40248 wxPyEndAllowThreads(__tstate);
40249 if (PyErr_Occurred()) SWIG_fail;
40250 }
40251 Py_INCREF(Py_None); resultobj = Py_None;
40252 return resultobj;
40253 fail:
40254 return NULL;
40255 }
40256
40257
40258 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40259 PyObject *resultobj;
40260 wxSizer *arg1 = (wxSizer *) 0 ;
40261 PyObject * obj0 = 0 ;
40262 char *kwnames[] = {
40263 (char *) "self", NULL
40264 };
40265
40266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40268 if (SWIG_arg_fail(1)) SWIG_fail;
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 (arg1)->DeleteWindows();
40272
40273 wxPyEndAllowThreads(__tstate);
40274 if (PyErr_Occurred()) SWIG_fail;
40275 }
40276 Py_INCREF(Py_None); resultobj = Py_None;
40277 return resultobj;
40278 fail:
40279 return NULL;
40280 }
40281
40282
40283 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40284 PyObject *resultobj;
40285 wxSizer *arg1 = (wxSizer *) 0 ;
40286 PyObject *result;
40287 PyObject * obj0 = 0 ;
40288 char *kwnames[] = {
40289 (char *) "self", NULL
40290 };
40291
40292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40294 if (SWIG_arg_fail(1)) SWIG_fail;
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = (PyObject *)wxSizer_GetChildren(arg1);
40298
40299 wxPyEndAllowThreads(__tstate);
40300 if (PyErr_Occurred()) SWIG_fail;
40301 }
40302 resultobj = result;
40303 return resultobj;
40304 fail:
40305 return NULL;
40306 }
40307
40308
40309 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40310 PyObject *resultobj;
40311 wxSizer *arg1 = (wxSizer *) 0 ;
40312 PyObject *arg2 = (PyObject *) 0 ;
40313 bool arg3 = (bool) true ;
40314 bool arg4 = (bool) false ;
40315 bool result;
40316 PyObject * obj0 = 0 ;
40317 PyObject * obj1 = 0 ;
40318 PyObject * obj2 = 0 ;
40319 PyObject * obj3 = 0 ;
40320 char *kwnames[] = {
40321 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40322 };
40323
40324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40326 if (SWIG_arg_fail(1)) SWIG_fail;
40327 arg2 = obj1;
40328 if (obj2) {
40329 {
40330 arg3 = (bool)(SWIG_As_bool(obj2));
40331 if (SWIG_arg_fail(3)) SWIG_fail;
40332 }
40333 }
40334 if (obj3) {
40335 {
40336 arg4 = (bool)(SWIG_As_bool(obj3));
40337 if (SWIG_arg_fail(4)) SWIG_fail;
40338 }
40339 }
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40343
40344 wxPyEndAllowThreads(__tstate);
40345 if (PyErr_Occurred()) SWIG_fail;
40346 }
40347 {
40348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40349 }
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj;
40358 wxSizer *arg1 = (wxSizer *) 0 ;
40359 PyObject *arg2 = (PyObject *) 0 ;
40360 bool result;
40361 PyObject * obj0 = 0 ;
40362 PyObject * obj1 = 0 ;
40363 char *kwnames[] = {
40364 (char *) "self",(char *) "item", NULL
40365 };
40366
40367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40369 if (SWIG_arg_fail(1)) SWIG_fail;
40370 arg2 = obj1;
40371 {
40372 PyThreadState* __tstate = wxPyBeginAllowThreads();
40373 result = (bool)wxSizer_IsShown(arg1,arg2);
40374
40375 wxPyEndAllowThreads(__tstate);
40376 if (PyErr_Occurred()) SWIG_fail;
40377 }
40378 {
40379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40380 }
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40388 PyObject *resultobj;
40389 wxSizer *arg1 = (wxSizer *) 0 ;
40390 bool arg2 ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 char *kwnames[] = {
40394 (char *) "self",(char *) "show", NULL
40395 };
40396
40397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40399 if (SWIG_arg_fail(1)) SWIG_fail;
40400 {
40401 arg2 = (bool)(SWIG_As_bool(obj1));
40402 if (SWIG_arg_fail(2)) SWIG_fail;
40403 }
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 (arg1)->ShowItems(arg2);
40407
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 Py_INCREF(Py_None); resultobj = Py_None;
40412 return resultobj;
40413 fail:
40414 return NULL;
40415 }
40416
40417
40418 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40419 PyObject *obj;
40420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40421 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40422 Py_INCREF(obj);
40423 return Py_BuildValue((char *)"");
40424 }
40425 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj;
40427 wxPySizer *result;
40428 char *kwnames[] = {
40429 NULL
40430 };
40431
40432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 result = (wxPySizer *)new wxPySizer();
40436
40437 wxPyEndAllowThreads(__tstate);
40438 if (PyErr_Occurred()) SWIG_fail;
40439 }
40440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40441 return resultobj;
40442 fail:
40443 return NULL;
40444 }
40445
40446
40447 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40448 PyObject *resultobj;
40449 wxPySizer *arg1 = (wxPySizer *) 0 ;
40450 PyObject *arg2 = (PyObject *) 0 ;
40451 PyObject *arg3 = (PyObject *) 0 ;
40452 PyObject * obj0 = 0 ;
40453 PyObject * obj1 = 0 ;
40454 PyObject * obj2 = 0 ;
40455 char *kwnames[] = {
40456 (char *) "self",(char *) "self",(char *) "_class", NULL
40457 };
40458
40459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40461 if (SWIG_arg_fail(1)) SWIG_fail;
40462 arg2 = obj1;
40463 arg3 = obj2;
40464 {
40465 PyThreadState* __tstate = wxPyBeginAllowThreads();
40466 (arg1)->_setCallbackInfo(arg2,arg3);
40467
40468 wxPyEndAllowThreads(__tstate);
40469 if (PyErr_Occurred()) SWIG_fail;
40470 }
40471 Py_INCREF(Py_None); resultobj = Py_None;
40472 return resultobj;
40473 fail:
40474 return NULL;
40475 }
40476
40477
40478 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40479 PyObject *obj;
40480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40481 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40482 Py_INCREF(obj);
40483 return Py_BuildValue((char *)"");
40484 }
40485 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40486 PyObject *resultobj;
40487 int arg1 = (int) wxHORIZONTAL ;
40488 wxBoxSizer *result;
40489 PyObject * obj0 = 0 ;
40490 char *kwnames[] = {
40491 (char *) "orient", NULL
40492 };
40493
40494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40495 if (obj0) {
40496 {
40497 arg1 = (int)(SWIG_As_int(obj0));
40498 if (SWIG_arg_fail(1)) SWIG_fail;
40499 }
40500 }
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40504
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40509 return resultobj;
40510 fail:
40511 return NULL;
40512 }
40513
40514
40515 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj;
40517 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40518 int result;
40519 PyObject * obj0 = 0 ;
40520 char *kwnames[] = {
40521 (char *) "self", NULL
40522 };
40523
40524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40526 if (SWIG_arg_fail(1)) SWIG_fail;
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 result = (int)(arg1)->GetOrientation();
40530
40531 wxPyEndAllowThreads(__tstate);
40532 if (PyErr_Occurred()) SWIG_fail;
40533 }
40534 {
40535 resultobj = SWIG_From_int((int)(result));
40536 }
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40544 PyObject *resultobj;
40545 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40546 int arg2 ;
40547 PyObject * obj0 = 0 ;
40548 PyObject * obj1 = 0 ;
40549 char *kwnames[] = {
40550 (char *) "self",(char *) "orient", NULL
40551 };
40552
40553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40555 if (SWIG_arg_fail(1)) SWIG_fail;
40556 {
40557 arg2 = (int)(SWIG_As_int(obj1));
40558 if (SWIG_arg_fail(2)) SWIG_fail;
40559 }
40560 {
40561 PyThreadState* __tstate = wxPyBeginAllowThreads();
40562 (arg1)->SetOrientation(arg2);
40563
40564 wxPyEndAllowThreads(__tstate);
40565 if (PyErr_Occurred()) SWIG_fail;
40566 }
40567 Py_INCREF(Py_None); resultobj = Py_None;
40568 return resultobj;
40569 fail:
40570 return NULL;
40571 }
40572
40573
40574 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40575 PyObject *obj;
40576 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40577 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40578 Py_INCREF(obj);
40579 return Py_BuildValue((char *)"");
40580 }
40581 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj;
40583 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40584 int arg2 = (int) wxHORIZONTAL ;
40585 wxStaticBoxSizer *result;
40586 PyObject * obj0 = 0 ;
40587 PyObject * obj1 = 0 ;
40588 char *kwnames[] = {
40589 (char *) "box",(char *) "orient", NULL
40590 };
40591
40592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40594 if (SWIG_arg_fail(1)) SWIG_fail;
40595 if (obj1) {
40596 {
40597 arg2 = (int)(SWIG_As_int(obj1));
40598 if (SWIG_arg_fail(2)) SWIG_fail;
40599 }
40600 }
40601 {
40602 PyThreadState* __tstate = wxPyBeginAllowThreads();
40603 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40604
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40609 return resultobj;
40610 fail:
40611 return NULL;
40612 }
40613
40614
40615 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40616 PyObject *resultobj;
40617 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40618 wxStaticBox *result;
40619 PyObject * obj0 = 0 ;
40620 char *kwnames[] = {
40621 (char *) "self", NULL
40622 };
40623
40624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40626 if (SWIG_arg_fail(1)) SWIG_fail;
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 result = (wxStaticBox *)(arg1)->GetStaticBox();
40630
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 {
40635 resultobj = wxPyMake_wxObject(result, 0);
40636 }
40637 return resultobj;
40638 fail:
40639 return NULL;
40640 }
40641
40642
40643 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40644 PyObject *obj;
40645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40646 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40647 Py_INCREF(obj);
40648 return Py_BuildValue((char *)"");
40649 }
40650 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40651 PyObject *resultobj;
40652 int arg1 = (int) 1 ;
40653 int arg2 = (int) 0 ;
40654 int arg3 = (int) 0 ;
40655 int arg4 = (int) 0 ;
40656 wxGridSizer *result;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 PyObject * obj2 = 0 ;
40660 PyObject * obj3 = 0 ;
40661 char *kwnames[] = {
40662 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40663 };
40664
40665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40666 if (obj0) {
40667 {
40668 arg1 = (int)(SWIG_As_int(obj0));
40669 if (SWIG_arg_fail(1)) SWIG_fail;
40670 }
40671 }
40672 if (obj1) {
40673 {
40674 arg2 = (int)(SWIG_As_int(obj1));
40675 if (SWIG_arg_fail(2)) SWIG_fail;
40676 }
40677 }
40678 if (obj2) {
40679 {
40680 arg3 = (int)(SWIG_As_int(obj2));
40681 if (SWIG_arg_fail(3)) SWIG_fail;
40682 }
40683 }
40684 if (obj3) {
40685 {
40686 arg4 = (int)(SWIG_As_int(obj3));
40687 if (SWIG_arg_fail(4)) SWIG_fail;
40688 }
40689 }
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40693
40694 wxPyEndAllowThreads(__tstate);
40695 if (PyErr_Occurred()) SWIG_fail;
40696 }
40697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj;
40706 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40707 int arg2 ;
40708 PyObject * obj0 = 0 ;
40709 PyObject * obj1 = 0 ;
40710 char *kwnames[] = {
40711 (char *) "self",(char *) "cols", NULL
40712 };
40713
40714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40716 if (SWIG_arg_fail(1)) SWIG_fail;
40717 {
40718 arg2 = (int)(SWIG_As_int(obj1));
40719 if (SWIG_arg_fail(2)) SWIG_fail;
40720 }
40721 {
40722 PyThreadState* __tstate = wxPyBeginAllowThreads();
40723 (arg1)->SetCols(arg2);
40724
40725 wxPyEndAllowThreads(__tstate);
40726 if (PyErr_Occurred()) SWIG_fail;
40727 }
40728 Py_INCREF(Py_None); resultobj = Py_None;
40729 return resultobj;
40730 fail:
40731 return NULL;
40732 }
40733
40734
40735 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40736 PyObject *resultobj;
40737 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40738 int arg2 ;
40739 PyObject * obj0 = 0 ;
40740 PyObject * obj1 = 0 ;
40741 char *kwnames[] = {
40742 (char *) "self",(char *) "rows", NULL
40743 };
40744
40745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40747 if (SWIG_arg_fail(1)) SWIG_fail;
40748 {
40749 arg2 = (int)(SWIG_As_int(obj1));
40750 if (SWIG_arg_fail(2)) SWIG_fail;
40751 }
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 (arg1)->SetRows(arg2);
40755
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 Py_INCREF(Py_None); resultobj = Py_None;
40760 return resultobj;
40761 fail:
40762 return NULL;
40763 }
40764
40765
40766 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40767 PyObject *resultobj;
40768 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40769 int arg2 ;
40770 PyObject * obj0 = 0 ;
40771 PyObject * obj1 = 0 ;
40772 char *kwnames[] = {
40773 (char *) "self",(char *) "gap", NULL
40774 };
40775
40776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40778 if (SWIG_arg_fail(1)) SWIG_fail;
40779 {
40780 arg2 = (int)(SWIG_As_int(obj1));
40781 if (SWIG_arg_fail(2)) SWIG_fail;
40782 }
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 (arg1)->SetVGap(arg2);
40786
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 Py_INCREF(Py_None); resultobj = Py_None;
40791 return resultobj;
40792 fail:
40793 return NULL;
40794 }
40795
40796
40797 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40798 PyObject *resultobj;
40799 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40800 int arg2 ;
40801 PyObject * obj0 = 0 ;
40802 PyObject * obj1 = 0 ;
40803 char *kwnames[] = {
40804 (char *) "self",(char *) "gap", NULL
40805 };
40806
40807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40809 if (SWIG_arg_fail(1)) SWIG_fail;
40810 {
40811 arg2 = (int)(SWIG_As_int(obj1));
40812 if (SWIG_arg_fail(2)) SWIG_fail;
40813 }
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 (arg1)->SetHGap(arg2);
40817
40818 wxPyEndAllowThreads(__tstate);
40819 if (PyErr_Occurred()) SWIG_fail;
40820 }
40821 Py_INCREF(Py_None); resultobj = Py_None;
40822 return resultobj;
40823 fail:
40824 return NULL;
40825 }
40826
40827
40828 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40829 PyObject *resultobj;
40830 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40831 int result;
40832 PyObject * obj0 = 0 ;
40833 char *kwnames[] = {
40834 (char *) "self", NULL
40835 };
40836
40837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40839 if (SWIG_arg_fail(1)) SWIG_fail;
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 result = (int)(arg1)->GetCols();
40843
40844 wxPyEndAllowThreads(__tstate);
40845 if (PyErr_Occurred()) SWIG_fail;
40846 }
40847 {
40848 resultobj = SWIG_From_int((int)(result));
40849 }
40850 return resultobj;
40851 fail:
40852 return NULL;
40853 }
40854
40855
40856 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40857 PyObject *resultobj;
40858 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40859 int result;
40860 PyObject * obj0 = 0 ;
40861 char *kwnames[] = {
40862 (char *) "self", NULL
40863 };
40864
40865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40867 if (SWIG_arg_fail(1)) SWIG_fail;
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 result = (int)(arg1)->GetRows();
40871
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 {
40876 resultobj = SWIG_From_int((int)(result));
40877 }
40878 return resultobj;
40879 fail:
40880 return NULL;
40881 }
40882
40883
40884 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40885 PyObject *resultobj;
40886 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40887 int result;
40888 PyObject * obj0 = 0 ;
40889 char *kwnames[] = {
40890 (char *) "self", NULL
40891 };
40892
40893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40895 if (SWIG_arg_fail(1)) SWIG_fail;
40896 {
40897 PyThreadState* __tstate = wxPyBeginAllowThreads();
40898 result = (int)(arg1)->GetVGap();
40899
40900 wxPyEndAllowThreads(__tstate);
40901 if (PyErr_Occurred()) SWIG_fail;
40902 }
40903 {
40904 resultobj = SWIG_From_int((int)(result));
40905 }
40906 return resultobj;
40907 fail:
40908 return NULL;
40909 }
40910
40911
40912 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40913 PyObject *resultobj;
40914 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40915 int result;
40916 PyObject * obj0 = 0 ;
40917 char *kwnames[] = {
40918 (char *) "self", NULL
40919 };
40920
40921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40923 if (SWIG_arg_fail(1)) SWIG_fail;
40924 {
40925 PyThreadState* __tstate = wxPyBeginAllowThreads();
40926 result = (int)(arg1)->GetHGap();
40927
40928 wxPyEndAllowThreads(__tstate);
40929 if (PyErr_Occurred()) SWIG_fail;
40930 }
40931 {
40932 resultobj = SWIG_From_int((int)(result));
40933 }
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40941 PyObject *obj;
40942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40943 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40944 Py_INCREF(obj);
40945 return Py_BuildValue((char *)"");
40946 }
40947 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40948 PyObject *resultobj;
40949 int arg1 = (int) 1 ;
40950 int arg2 = (int) 0 ;
40951 int arg3 = (int) 0 ;
40952 int arg4 = (int) 0 ;
40953 wxFlexGridSizer *result;
40954 PyObject * obj0 = 0 ;
40955 PyObject * obj1 = 0 ;
40956 PyObject * obj2 = 0 ;
40957 PyObject * obj3 = 0 ;
40958 char *kwnames[] = {
40959 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40960 };
40961
40962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40963 if (obj0) {
40964 {
40965 arg1 = (int)(SWIG_As_int(obj0));
40966 if (SWIG_arg_fail(1)) SWIG_fail;
40967 }
40968 }
40969 if (obj1) {
40970 {
40971 arg2 = (int)(SWIG_As_int(obj1));
40972 if (SWIG_arg_fail(2)) SWIG_fail;
40973 }
40974 }
40975 if (obj2) {
40976 {
40977 arg3 = (int)(SWIG_As_int(obj2));
40978 if (SWIG_arg_fail(3)) SWIG_fail;
40979 }
40980 }
40981 if (obj3) {
40982 {
40983 arg4 = (int)(SWIG_As_int(obj3));
40984 if (SWIG_arg_fail(4)) SWIG_fail;
40985 }
40986 }
40987 {
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40990
40991 wxPyEndAllowThreads(__tstate);
40992 if (PyErr_Occurred()) SWIG_fail;
40993 }
40994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40995 return resultobj;
40996 fail:
40997 return NULL;
40998 }
40999
41000
41001 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41002 PyObject *resultobj;
41003 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41004 size_t arg2 ;
41005 int arg3 = (int) 0 ;
41006 PyObject * obj0 = 0 ;
41007 PyObject * obj1 = 0 ;
41008 PyObject * obj2 = 0 ;
41009 char *kwnames[] = {
41010 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41011 };
41012
41013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41015 if (SWIG_arg_fail(1)) SWIG_fail;
41016 {
41017 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41018 if (SWIG_arg_fail(2)) SWIG_fail;
41019 }
41020 if (obj2) {
41021 {
41022 arg3 = (int)(SWIG_As_int(obj2));
41023 if (SWIG_arg_fail(3)) SWIG_fail;
41024 }
41025 }
41026 {
41027 PyThreadState* __tstate = wxPyBeginAllowThreads();
41028 (arg1)->AddGrowableRow(arg2,arg3);
41029
41030 wxPyEndAllowThreads(__tstate);
41031 if (PyErr_Occurred()) SWIG_fail;
41032 }
41033 Py_INCREF(Py_None); resultobj = Py_None;
41034 return resultobj;
41035 fail:
41036 return NULL;
41037 }
41038
41039
41040 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41041 PyObject *resultobj;
41042 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41043 size_t arg2 ;
41044 PyObject * obj0 = 0 ;
41045 PyObject * obj1 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self",(char *) "idx", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 {
41054 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41055 if (SWIG_arg_fail(2)) SWIG_fail;
41056 }
41057 {
41058 PyThreadState* __tstate = wxPyBeginAllowThreads();
41059 (arg1)->RemoveGrowableRow(arg2);
41060
41061 wxPyEndAllowThreads(__tstate);
41062 if (PyErr_Occurred()) SWIG_fail;
41063 }
41064 Py_INCREF(Py_None); resultobj = Py_None;
41065 return resultobj;
41066 fail:
41067 return NULL;
41068 }
41069
41070
41071 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41072 PyObject *resultobj;
41073 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41074 size_t arg2 ;
41075 int arg3 = (int) 0 ;
41076 PyObject * obj0 = 0 ;
41077 PyObject * obj1 = 0 ;
41078 PyObject * obj2 = 0 ;
41079 char *kwnames[] = {
41080 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41081 };
41082
41083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41085 if (SWIG_arg_fail(1)) SWIG_fail;
41086 {
41087 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41088 if (SWIG_arg_fail(2)) SWIG_fail;
41089 }
41090 if (obj2) {
41091 {
41092 arg3 = (int)(SWIG_As_int(obj2));
41093 if (SWIG_arg_fail(3)) SWIG_fail;
41094 }
41095 }
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 (arg1)->AddGrowableCol(arg2,arg3);
41099
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 Py_INCREF(Py_None); resultobj = Py_None;
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj;
41112 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41113 size_t arg2 ;
41114 PyObject * obj0 = 0 ;
41115 PyObject * obj1 = 0 ;
41116 char *kwnames[] = {
41117 (char *) "self",(char *) "idx", NULL
41118 };
41119
41120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41122 if (SWIG_arg_fail(1)) SWIG_fail;
41123 {
41124 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41125 if (SWIG_arg_fail(2)) SWIG_fail;
41126 }
41127 {
41128 PyThreadState* __tstate = wxPyBeginAllowThreads();
41129 (arg1)->RemoveGrowableCol(arg2);
41130
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 Py_INCREF(Py_None); resultobj = Py_None;
41135 return resultobj;
41136 fail:
41137 return NULL;
41138 }
41139
41140
41141 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41142 PyObject *resultobj;
41143 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41144 int arg2 ;
41145 PyObject * obj0 = 0 ;
41146 PyObject * obj1 = 0 ;
41147 char *kwnames[] = {
41148 (char *) "self",(char *) "direction", NULL
41149 };
41150
41151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41153 if (SWIG_arg_fail(1)) SWIG_fail;
41154 {
41155 arg2 = (int)(SWIG_As_int(obj1));
41156 if (SWIG_arg_fail(2)) SWIG_fail;
41157 }
41158 {
41159 PyThreadState* __tstate = wxPyBeginAllowThreads();
41160 (arg1)->SetFlexibleDirection(arg2);
41161
41162 wxPyEndAllowThreads(__tstate);
41163 if (PyErr_Occurred()) SWIG_fail;
41164 }
41165 Py_INCREF(Py_None); resultobj = Py_None;
41166 return resultobj;
41167 fail:
41168 return NULL;
41169 }
41170
41171
41172 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41173 PyObject *resultobj;
41174 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41175 int result;
41176 PyObject * obj0 = 0 ;
41177 char *kwnames[] = {
41178 (char *) "self", NULL
41179 };
41180
41181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41183 if (SWIG_arg_fail(1)) SWIG_fail;
41184 {
41185 PyThreadState* __tstate = wxPyBeginAllowThreads();
41186 result = (int)(arg1)->GetFlexibleDirection();
41187
41188 wxPyEndAllowThreads(__tstate);
41189 if (PyErr_Occurred()) SWIG_fail;
41190 }
41191 {
41192 resultobj = SWIG_From_int((int)(result));
41193 }
41194 return resultobj;
41195 fail:
41196 return NULL;
41197 }
41198
41199
41200 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41201 PyObject *resultobj;
41202 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41203 wxFlexSizerGrowMode arg2 ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char *kwnames[] = {
41207 (char *) "self",(char *) "mode", NULL
41208 };
41209
41210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41212 if (SWIG_arg_fail(1)) SWIG_fail;
41213 {
41214 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41215 if (SWIG_arg_fail(2)) SWIG_fail;
41216 }
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41220
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 Py_INCREF(Py_None); resultobj = Py_None;
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41232 PyObject *resultobj;
41233 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41234 wxFlexSizerGrowMode result;
41235 PyObject * obj0 = 0 ;
41236 char *kwnames[] = {
41237 (char *) "self", NULL
41238 };
41239
41240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41242 if (SWIG_arg_fail(1)) SWIG_fail;
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 resultobj = SWIG_From_int((result));
41251 return resultobj;
41252 fail:
41253 return NULL;
41254 }
41255
41256
41257 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41258 PyObject *resultobj;
41259 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41260 wxArrayInt *result;
41261 PyObject * obj0 = 0 ;
41262 char *kwnames[] = {
41263 (char *) "self", NULL
41264 };
41265
41266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41268 if (SWIG_arg_fail(1)) SWIG_fail;
41269 {
41270 PyThreadState* __tstate = wxPyBeginAllowThreads();
41271 {
41272 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41273 result = (wxArrayInt *) &_result_ref;
41274 }
41275
41276 wxPyEndAllowThreads(__tstate);
41277 if (PyErr_Occurred()) SWIG_fail;
41278 }
41279 {
41280 resultobj = PyList_New(0);
41281 size_t idx;
41282 for (idx = 0; idx < result->GetCount(); idx += 1) {
41283 PyObject* val = PyInt_FromLong( result->Item(idx) );
41284 PyList_Append(resultobj, val);
41285 Py_DECREF(val);
41286 }
41287 }
41288 return resultobj;
41289 fail:
41290 return NULL;
41291 }
41292
41293
41294 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41295 PyObject *resultobj;
41296 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41297 wxArrayInt *result;
41298 PyObject * obj0 = 0 ;
41299 char *kwnames[] = {
41300 (char *) "self", NULL
41301 };
41302
41303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41305 if (SWIG_arg_fail(1)) SWIG_fail;
41306 {
41307 PyThreadState* __tstate = wxPyBeginAllowThreads();
41308 {
41309 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41310 result = (wxArrayInt *) &_result_ref;
41311 }
41312
41313 wxPyEndAllowThreads(__tstate);
41314 if (PyErr_Occurred()) SWIG_fail;
41315 }
41316 {
41317 resultobj = PyList_New(0);
41318 size_t idx;
41319 for (idx = 0; idx < result->GetCount(); idx += 1) {
41320 PyObject* val = PyInt_FromLong( result->Item(idx) );
41321 PyList_Append(resultobj, val);
41322 Py_DECREF(val);
41323 }
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41332 PyObject *obj;
41333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41334 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41335 Py_INCREF(obj);
41336 return Py_BuildValue((char *)"");
41337 }
41338 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41339 PyObject *resultobj;
41340 wxStdDialogButtonSizer *result;
41341 char *kwnames[] = {
41342 NULL
41343 };
41344
41345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41346 {
41347 PyThreadState* __tstate = wxPyBeginAllowThreads();
41348 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41349
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41354 return resultobj;
41355 fail:
41356 return NULL;
41357 }
41358
41359
41360 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41361 PyObject *resultobj;
41362 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41363 wxButton *arg2 = (wxButton *) 0 ;
41364 PyObject * obj0 = 0 ;
41365 PyObject * obj1 = 0 ;
41366 char *kwnames[] = {
41367 (char *) "self",(char *) "button", NULL
41368 };
41369
41370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41372 if (SWIG_arg_fail(1)) SWIG_fail;
41373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41374 if (SWIG_arg_fail(2)) SWIG_fail;
41375 {
41376 PyThreadState* __tstate = wxPyBeginAllowThreads();
41377 (arg1)->AddButton(arg2);
41378
41379 wxPyEndAllowThreads(__tstate);
41380 if (PyErr_Occurred()) SWIG_fail;
41381 }
41382 Py_INCREF(Py_None); resultobj = Py_None;
41383 return resultobj;
41384 fail:
41385 return NULL;
41386 }
41387
41388
41389 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41390 PyObject *resultobj;
41391 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41392 PyObject * obj0 = 0 ;
41393 char *kwnames[] = {
41394 (char *) "self", NULL
41395 };
41396
41397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41399 if (SWIG_arg_fail(1)) SWIG_fail;
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 (arg1)->Realize();
41403
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 Py_INCREF(Py_None); resultobj = Py_None;
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj;
41416 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41417 wxButton *arg2 = (wxButton *) 0 ;
41418 PyObject * obj0 = 0 ;
41419 PyObject * obj1 = 0 ;
41420 char *kwnames[] = {
41421 (char *) "self",(char *) "button", NULL
41422 };
41423
41424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41426 if (SWIG_arg_fail(1)) SWIG_fail;
41427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41428 if (SWIG_arg_fail(2)) SWIG_fail;
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 (arg1)->SetAffirmativeButton(arg2);
41432
41433 wxPyEndAllowThreads(__tstate);
41434 if (PyErr_Occurred()) SWIG_fail;
41435 }
41436 Py_INCREF(Py_None); resultobj = Py_None;
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj;
41445 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41446 wxButton *arg2 = (wxButton *) 0 ;
41447 PyObject * obj0 = 0 ;
41448 PyObject * obj1 = 0 ;
41449 char *kwnames[] = {
41450 (char *) "self",(char *) "button", NULL
41451 };
41452
41453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41455 if (SWIG_arg_fail(1)) SWIG_fail;
41456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41457 if (SWIG_arg_fail(2)) SWIG_fail;
41458 {
41459 PyThreadState* __tstate = wxPyBeginAllowThreads();
41460 (arg1)->SetNegativeButton(arg2);
41461
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 Py_INCREF(Py_None); resultobj = Py_None;
41466 return resultobj;
41467 fail:
41468 return NULL;
41469 }
41470
41471
41472 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41473 PyObject *resultobj;
41474 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41475 wxButton *arg2 = (wxButton *) 0 ;
41476 PyObject * obj0 = 0 ;
41477 PyObject * obj1 = 0 ;
41478 char *kwnames[] = {
41479 (char *) "self",(char *) "button", NULL
41480 };
41481
41482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41484 if (SWIG_arg_fail(1)) SWIG_fail;
41485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41486 if (SWIG_arg_fail(2)) SWIG_fail;
41487 {
41488 PyThreadState* __tstate = wxPyBeginAllowThreads();
41489 (arg1)->SetCancelButton(arg2);
41490
41491 wxPyEndAllowThreads(__tstate);
41492 if (PyErr_Occurred()) SWIG_fail;
41493 }
41494 Py_INCREF(Py_None); resultobj = Py_None;
41495 return resultobj;
41496 fail:
41497 return NULL;
41498 }
41499
41500
41501 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41502 PyObject *resultobj;
41503 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41504 wxButton *result;
41505 PyObject * obj0 = 0 ;
41506 char *kwnames[] = {
41507 (char *) "self", NULL
41508 };
41509
41510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41512 if (SWIG_arg_fail(1)) SWIG_fail;
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41516
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 {
41521 resultobj = wxPyMake_wxObject(result, 0);
41522 }
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj;
41531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41532 wxButton *result;
41533 PyObject * obj0 = 0 ;
41534 char *kwnames[] = {
41535 (char *) "self", NULL
41536 };
41537
41538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41540 if (SWIG_arg_fail(1)) SWIG_fail;
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41544
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 {
41549 resultobj = wxPyMake_wxObject(result, 0);
41550 }
41551 return resultobj;
41552 fail:
41553 return NULL;
41554 }
41555
41556
41557 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41558 PyObject *resultobj;
41559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41560 wxButton *result;
41561 PyObject * obj0 = 0 ;
41562 char *kwnames[] = {
41563 (char *) "self", NULL
41564 };
41565
41566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41568 if (SWIG_arg_fail(1)) SWIG_fail;
41569 {
41570 PyThreadState* __tstate = wxPyBeginAllowThreads();
41571 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41572
41573 wxPyEndAllowThreads(__tstate);
41574 if (PyErr_Occurred()) SWIG_fail;
41575 }
41576 {
41577 resultobj = wxPyMake_wxObject(result, 0);
41578 }
41579 return resultobj;
41580 fail:
41581 return NULL;
41582 }
41583
41584
41585 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41586 PyObject *resultobj;
41587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41588 wxButton *result;
41589 PyObject * obj0 = 0 ;
41590 char *kwnames[] = {
41591 (char *) "self", NULL
41592 };
41593
41594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41596 if (SWIG_arg_fail(1)) SWIG_fail;
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41600
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 {
41605 resultobj = wxPyMake_wxObject(result, 0);
41606 }
41607 return resultobj;
41608 fail:
41609 return NULL;
41610 }
41611
41612
41613 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41614 PyObject *resultobj;
41615 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41616 wxButton *result;
41617 PyObject * obj0 = 0 ;
41618 char *kwnames[] = {
41619 (char *) "self", NULL
41620 };
41621
41622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41624 if (SWIG_arg_fail(1)) SWIG_fail;
41625 {
41626 PyThreadState* __tstate = wxPyBeginAllowThreads();
41627 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41628
41629 wxPyEndAllowThreads(__tstate);
41630 if (PyErr_Occurred()) SWIG_fail;
41631 }
41632 {
41633 resultobj = wxPyMake_wxObject(result, 0);
41634 }
41635 return resultobj;
41636 fail:
41637 return NULL;
41638 }
41639
41640
41641 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41642 PyObject *obj;
41643 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41644 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41645 Py_INCREF(obj);
41646 return Py_BuildValue((char *)"");
41647 }
41648 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41649 PyObject *resultobj;
41650 int arg1 = (int) 0 ;
41651 int arg2 = (int) 0 ;
41652 wxGBPosition *result;
41653 PyObject * obj0 = 0 ;
41654 PyObject * obj1 = 0 ;
41655 char *kwnames[] = {
41656 (char *) "row",(char *) "col", NULL
41657 };
41658
41659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41660 if (obj0) {
41661 {
41662 arg1 = (int)(SWIG_As_int(obj0));
41663 if (SWIG_arg_fail(1)) SWIG_fail;
41664 }
41665 }
41666 if (obj1) {
41667 {
41668 arg2 = (int)(SWIG_As_int(obj1));
41669 if (SWIG_arg_fail(2)) SWIG_fail;
41670 }
41671 }
41672 {
41673 PyThreadState* __tstate = wxPyBeginAllowThreads();
41674 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41675
41676 wxPyEndAllowThreads(__tstate);
41677 if (PyErr_Occurred()) SWIG_fail;
41678 }
41679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41687 PyObject *resultobj;
41688 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41689 int result;
41690 PyObject * obj0 = 0 ;
41691 char *kwnames[] = {
41692 (char *) "self", NULL
41693 };
41694
41695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41697 if (SWIG_arg_fail(1)) SWIG_fail;
41698 {
41699 PyThreadState* __tstate = wxPyBeginAllowThreads();
41700 result = (int)((wxGBPosition const *)arg1)->GetRow();
41701
41702 wxPyEndAllowThreads(__tstate);
41703 if (PyErr_Occurred()) SWIG_fail;
41704 }
41705 {
41706 resultobj = SWIG_From_int((int)(result));
41707 }
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj;
41716 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41717 int result;
41718 PyObject * obj0 = 0 ;
41719 char *kwnames[] = {
41720 (char *) "self", NULL
41721 };
41722
41723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41725 if (SWIG_arg_fail(1)) SWIG_fail;
41726 {
41727 PyThreadState* __tstate = wxPyBeginAllowThreads();
41728 result = (int)((wxGBPosition const *)arg1)->GetCol();
41729
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 {
41734 resultobj = SWIG_From_int((int)(result));
41735 }
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj;
41744 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41745 int arg2 ;
41746 PyObject * obj0 = 0 ;
41747 PyObject * obj1 = 0 ;
41748 char *kwnames[] = {
41749 (char *) "self",(char *) "row", NULL
41750 };
41751
41752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41754 if (SWIG_arg_fail(1)) SWIG_fail;
41755 {
41756 arg2 = (int)(SWIG_As_int(obj1));
41757 if (SWIG_arg_fail(2)) SWIG_fail;
41758 }
41759 {
41760 PyThreadState* __tstate = wxPyBeginAllowThreads();
41761 (arg1)->SetRow(arg2);
41762
41763 wxPyEndAllowThreads(__tstate);
41764 if (PyErr_Occurred()) SWIG_fail;
41765 }
41766 Py_INCREF(Py_None); resultobj = Py_None;
41767 return resultobj;
41768 fail:
41769 return NULL;
41770 }
41771
41772
41773 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41774 PyObject *resultobj;
41775 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41776 int arg2 ;
41777 PyObject * obj0 = 0 ;
41778 PyObject * obj1 = 0 ;
41779 char *kwnames[] = {
41780 (char *) "self",(char *) "col", NULL
41781 };
41782
41783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41785 if (SWIG_arg_fail(1)) SWIG_fail;
41786 {
41787 arg2 = (int)(SWIG_As_int(obj1));
41788 if (SWIG_arg_fail(2)) SWIG_fail;
41789 }
41790 {
41791 PyThreadState* __tstate = wxPyBeginAllowThreads();
41792 (arg1)->SetCol(arg2);
41793
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 Py_INCREF(Py_None); resultobj = Py_None;
41798 return resultobj;
41799 fail:
41800 return NULL;
41801 }
41802
41803
41804 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41805 PyObject *resultobj;
41806 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41807 wxGBPosition *arg2 = 0 ;
41808 bool result;
41809 wxGBPosition temp2 ;
41810 PyObject * obj0 = 0 ;
41811 PyObject * obj1 = 0 ;
41812 char *kwnames[] = {
41813 (char *) "self",(char *) "other", NULL
41814 };
41815
41816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41818 if (SWIG_arg_fail(1)) SWIG_fail;
41819 {
41820 arg2 = &temp2;
41821 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41822 }
41823 {
41824 PyThreadState* __tstate = wxPyBeginAllowThreads();
41825 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41826
41827 wxPyEndAllowThreads(__tstate);
41828 if (PyErr_Occurred()) SWIG_fail;
41829 }
41830 {
41831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41832 }
41833 return resultobj;
41834 fail:
41835 return NULL;
41836 }
41837
41838
41839 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj;
41841 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41842 wxGBPosition *arg2 = 0 ;
41843 bool result;
41844 wxGBPosition temp2 ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 char *kwnames[] = {
41848 (char *) "self",(char *) "other", NULL
41849 };
41850
41851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41853 if (SWIG_arg_fail(1)) SWIG_fail;
41854 {
41855 arg2 = &temp2;
41856 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41857 }
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41861
41862 wxPyEndAllowThreads(__tstate);
41863 if (PyErr_Occurred()) SWIG_fail;
41864 }
41865 {
41866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41867 }
41868 return resultobj;
41869 fail:
41870 return NULL;
41871 }
41872
41873
41874 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41875 PyObject *resultobj;
41876 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41877 int arg2 = (int) 0 ;
41878 int arg3 = (int) 0 ;
41879 PyObject * obj0 = 0 ;
41880 PyObject * obj1 = 0 ;
41881 PyObject * obj2 = 0 ;
41882 char *kwnames[] = {
41883 (char *) "self",(char *) "row",(char *) "col", NULL
41884 };
41885
41886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41888 if (SWIG_arg_fail(1)) SWIG_fail;
41889 if (obj1) {
41890 {
41891 arg2 = (int)(SWIG_As_int(obj1));
41892 if (SWIG_arg_fail(2)) SWIG_fail;
41893 }
41894 }
41895 if (obj2) {
41896 {
41897 arg3 = (int)(SWIG_As_int(obj2));
41898 if (SWIG_arg_fail(3)) SWIG_fail;
41899 }
41900 }
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 wxGBPosition_Set(arg1,arg2,arg3);
41904
41905 wxPyEndAllowThreads(__tstate);
41906 if (PyErr_Occurred()) SWIG_fail;
41907 }
41908 Py_INCREF(Py_None); resultobj = Py_None;
41909 return resultobj;
41910 fail:
41911 return NULL;
41912 }
41913
41914
41915 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41916 PyObject *resultobj;
41917 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41918 PyObject *result;
41919 PyObject * obj0 = 0 ;
41920 char *kwnames[] = {
41921 (char *) "self", NULL
41922 };
41923
41924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41926 if (SWIG_arg_fail(1)) SWIG_fail;
41927 {
41928 PyThreadState* __tstate = wxPyBeginAllowThreads();
41929 result = (PyObject *)wxGBPosition_Get(arg1);
41930
41931 wxPyEndAllowThreads(__tstate);
41932 if (PyErr_Occurred()) SWIG_fail;
41933 }
41934 resultobj = result;
41935 return resultobj;
41936 fail:
41937 return NULL;
41938 }
41939
41940
41941 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41942 PyObject *obj;
41943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41944 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41945 Py_INCREF(obj);
41946 return Py_BuildValue((char *)"");
41947 }
41948 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41949 PyObject *resultobj;
41950 int arg1 = (int) 1 ;
41951 int arg2 = (int) 1 ;
41952 wxGBSpan *result;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char *kwnames[] = {
41956 (char *) "rowspan",(char *) "colspan", NULL
41957 };
41958
41959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41960 if (obj0) {
41961 {
41962 arg1 = (int)(SWIG_As_int(obj0));
41963 if (SWIG_arg_fail(1)) SWIG_fail;
41964 }
41965 }
41966 if (obj1) {
41967 {
41968 arg2 = (int)(SWIG_As_int(obj1));
41969 if (SWIG_arg_fail(2)) SWIG_fail;
41970 }
41971 }
41972 {
41973 PyThreadState* __tstate = wxPyBeginAllowThreads();
41974 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41975
41976 wxPyEndAllowThreads(__tstate);
41977 if (PyErr_Occurred()) SWIG_fail;
41978 }
41979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41980 return resultobj;
41981 fail:
41982 return NULL;
41983 }
41984
41985
41986 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41987 PyObject *resultobj;
41988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41989 int result;
41990 PyObject * obj0 = 0 ;
41991 char *kwnames[] = {
41992 (char *) "self", NULL
41993 };
41994
41995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41997 if (SWIG_arg_fail(1)) SWIG_fail;
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42001
42002 wxPyEndAllowThreads(__tstate);
42003 if (PyErr_Occurred()) SWIG_fail;
42004 }
42005 {
42006 resultobj = SWIG_From_int((int)(result));
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj;
42016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42017 int result;
42018 PyObject * obj0 = 0 ;
42019 char *kwnames[] = {
42020 (char *) "self", NULL
42021 };
42022
42023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42025 if (SWIG_arg_fail(1)) SWIG_fail;
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42029
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 {
42034 resultobj = SWIG_From_int((int)(result));
42035 }
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj;
42044 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42045 int arg2 ;
42046 PyObject * obj0 = 0 ;
42047 PyObject * obj1 = 0 ;
42048 char *kwnames[] = {
42049 (char *) "self",(char *) "rowspan", NULL
42050 };
42051
42052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42054 if (SWIG_arg_fail(1)) SWIG_fail;
42055 {
42056 arg2 = (int)(SWIG_As_int(obj1));
42057 if (SWIG_arg_fail(2)) SWIG_fail;
42058 }
42059 {
42060 PyThreadState* __tstate = wxPyBeginAllowThreads();
42061 (arg1)->SetRowspan(arg2);
42062
42063 wxPyEndAllowThreads(__tstate);
42064 if (PyErr_Occurred()) SWIG_fail;
42065 }
42066 Py_INCREF(Py_None); resultobj = Py_None;
42067 return resultobj;
42068 fail:
42069 return NULL;
42070 }
42071
42072
42073 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42074 PyObject *resultobj;
42075 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42076 int arg2 ;
42077 PyObject * obj0 = 0 ;
42078 PyObject * obj1 = 0 ;
42079 char *kwnames[] = {
42080 (char *) "self",(char *) "colspan", NULL
42081 };
42082
42083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42085 if (SWIG_arg_fail(1)) SWIG_fail;
42086 {
42087 arg2 = (int)(SWIG_As_int(obj1));
42088 if (SWIG_arg_fail(2)) SWIG_fail;
42089 }
42090 {
42091 PyThreadState* __tstate = wxPyBeginAllowThreads();
42092 (arg1)->SetColspan(arg2);
42093
42094 wxPyEndAllowThreads(__tstate);
42095 if (PyErr_Occurred()) SWIG_fail;
42096 }
42097 Py_INCREF(Py_None); resultobj = Py_None;
42098 return resultobj;
42099 fail:
42100 return NULL;
42101 }
42102
42103
42104 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42105 PyObject *resultobj;
42106 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42107 wxGBSpan *arg2 = 0 ;
42108 bool result;
42109 wxGBSpan temp2 ;
42110 PyObject * obj0 = 0 ;
42111 PyObject * obj1 = 0 ;
42112 char *kwnames[] = {
42113 (char *) "self",(char *) "other", NULL
42114 };
42115
42116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42118 if (SWIG_arg_fail(1)) SWIG_fail;
42119 {
42120 arg2 = &temp2;
42121 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42122 }
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42126
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 {
42131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42132 }
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj;
42141 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42142 wxGBSpan *arg2 = 0 ;
42143 bool result;
42144 wxGBSpan temp2 ;
42145 PyObject * obj0 = 0 ;
42146 PyObject * obj1 = 0 ;
42147 char *kwnames[] = {
42148 (char *) "self",(char *) "other", NULL
42149 };
42150
42151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42153 if (SWIG_arg_fail(1)) SWIG_fail;
42154 {
42155 arg2 = &temp2;
42156 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42157 }
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42161
42162 wxPyEndAllowThreads(__tstate);
42163 if (PyErr_Occurred()) SWIG_fail;
42164 }
42165 {
42166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42167 }
42168 return resultobj;
42169 fail:
42170 return NULL;
42171 }
42172
42173
42174 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42175 PyObject *resultobj;
42176 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42177 int arg2 = (int) 1 ;
42178 int arg3 = (int) 1 ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 PyObject * obj2 = 0 ;
42182 char *kwnames[] = {
42183 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42184 };
42185
42186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42188 if (SWIG_arg_fail(1)) SWIG_fail;
42189 if (obj1) {
42190 {
42191 arg2 = (int)(SWIG_As_int(obj1));
42192 if (SWIG_arg_fail(2)) SWIG_fail;
42193 }
42194 }
42195 if (obj2) {
42196 {
42197 arg3 = (int)(SWIG_As_int(obj2));
42198 if (SWIG_arg_fail(3)) SWIG_fail;
42199 }
42200 }
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 wxGBSpan_Set(arg1,arg2,arg3);
42204
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 Py_INCREF(Py_None); resultobj = Py_None;
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42216 PyObject *resultobj;
42217 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42218 PyObject *result;
42219 PyObject * obj0 = 0 ;
42220 char *kwnames[] = {
42221 (char *) "self", NULL
42222 };
42223
42224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42226 if (SWIG_arg_fail(1)) SWIG_fail;
42227 {
42228 PyThreadState* __tstate = wxPyBeginAllowThreads();
42229 result = (PyObject *)wxGBSpan_Get(arg1);
42230
42231 wxPyEndAllowThreads(__tstate);
42232 if (PyErr_Occurred()) SWIG_fail;
42233 }
42234 resultobj = result;
42235 return resultobj;
42236 fail:
42237 return NULL;
42238 }
42239
42240
42241 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42242 PyObject *obj;
42243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42244 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42245 Py_INCREF(obj);
42246 return Py_BuildValue((char *)"");
42247 }
42248 static int _wrap_DefaultSpan_set(PyObject *) {
42249 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42250 return 1;
42251 }
42252
42253
42254 static PyObject *_wrap_DefaultSpan_get(void) {
42255 PyObject *pyobj;
42256
42257 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42258 return pyobj;
42259 }
42260
42261
42262 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42263 PyObject *resultobj;
42264 wxGBSizerItem *result;
42265 char *kwnames[] = {
42266 NULL
42267 };
42268
42269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42270 {
42271 PyThreadState* __tstate = wxPyBeginAllowThreads();
42272 result = (wxGBSizerItem *)new wxGBSizerItem();
42273
42274 wxPyEndAllowThreads(__tstate);
42275 if (PyErr_Occurred()) SWIG_fail;
42276 }
42277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42278 return resultobj;
42279 fail:
42280 return NULL;
42281 }
42282
42283
42284 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42285 PyObject *resultobj;
42286 wxWindow *arg1 = (wxWindow *) 0 ;
42287 wxGBPosition *arg2 = 0 ;
42288 wxGBSpan *arg3 = 0 ;
42289 int arg4 ;
42290 int arg5 ;
42291 PyObject *arg6 = (PyObject *) NULL ;
42292 wxGBSizerItem *result;
42293 wxGBPosition temp2 ;
42294 wxGBSpan temp3 ;
42295 PyObject * obj0 = 0 ;
42296 PyObject * obj1 = 0 ;
42297 PyObject * obj2 = 0 ;
42298 PyObject * obj3 = 0 ;
42299 PyObject * obj4 = 0 ;
42300 PyObject * obj5 = 0 ;
42301 char *kwnames[] = {
42302 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42303 };
42304
42305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42307 if (SWIG_arg_fail(1)) SWIG_fail;
42308 {
42309 arg2 = &temp2;
42310 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42311 }
42312 {
42313 arg3 = &temp3;
42314 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42315 }
42316 {
42317 arg4 = (int)(SWIG_As_int(obj3));
42318 if (SWIG_arg_fail(4)) SWIG_fail;
42319 }
42320 {
42321 arg5 = (int)(SWIG_As_int(obj4));
42322 if (SWIG_arg_fail(5)) SWIG_fail;
42323 }
42324 if (obj5) {
42325 arg6 = obj5;
42326 }
42327 {
42328 PyThreadState* __tstate = wxPyBeginAllowThreads();
42329 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42330
42331 wxPyEndAllowThreads(__tstate);
42332 if (PyErr_Occurred()) SWIG_fail;
42333 }
42334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42342 PyObject *resultobj;
42343 wxSizer *arg1 = (wxSizer *) 0 ;
42344 wxGBPosition *arg2 = 0 ;
42345 wxGBSpan *arg3 = 0 ;
42346 int arg4 ;
42347 int arg5 ;
42348 PyObject *arg6 = (PyObject *) NULL ;
42349 wxGBSizerItem *result;
42350 wxGBPosition temp2 ;
42351 wxGBSpan temp3 ;
42352 PyObject * obj0 = 0 ;
42353 PyObject * obj1 = 0 ;
42354 PyObject * obj2 = 0 ;
42355 PyObject * obj3 = 0 ;
42356 PyObject * obj4 = 0 ;
42357 PyObject * obj5 = 0 ;
42358 char *kwnames[] = {
42359 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42360 };
42361
42362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42364 if (SWIG_arg_fail(1)) SWIG_fail;
42365 {
42366 arg2 = &temp2;
42367 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42368 }
42369 {
42370 arg3 = &temp3;
42371 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42372 }
42373 {
42374 arg4 = (int)(SWIG_As_int(obj3));
42375 if (SWIG_arg_fail(4)) SWIG_fail;
42376 }
42377 {
42378 arg5 = (int)(SWIG_As_int(obj4));
42379 if (SWIG_arg_fail(5)) SWIG_fail;
42380 }
42381 if (obj5) {
42382 arg6 = obj5;
42383 }
42384 {
42385 PyThreadState* __tstate = wxPyBeginAllowThreads();
42386 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42387
42388 wxPyEndAllowThreads(__tstate);
42389 if (PyErr_Occurred()) SWIG_fail;
42390 }
42391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42392 return resultobj;
42393 fail:
42394 return NULL;
42395 }
42396
42397
42398 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42399 PyObject *resultobj;
42400 int arg1 ;
42401 int arg2 ;
42402 wxGBPosition *arg3 = 0 ;
42403 wxGBSpan *arg4 = 0 ;
42404 int arg5 ;
42405 int arg6 ;
42406 PyObject *arg7 = (PyObject *) NULL ;
42407 wxGBSizerItem *result;
42408 wxGBPosition temp3 ;
42409 wxGBSpan temp4 ;
42410 PyObject * obj0 = 0 ;
42411 PyObject * obj1 = 0 ;
42412 PyObject * obj2 = 0 ;
42413 PyObject * obj3 = 0 ;
42414 PyObject * obj4 = 0 ;
42415 PyObject * obj5 = 0 ;
42416 PyObject * obj6 = 0 ;
42417 char *kwnames[] = {
42418 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42419 };
42420
42421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42422 {
42423 arg1 = (int)(SWIG_As_int(obj0));
42424 if (SWIG_arg_fail(1)) SWIG_fail;
42425 }
42426 {
42427 arg2 = (int)(SWIG_As_int(obj1));
42428 if (SWIG_arg_fail(2)) SWIG_fail;
42429 }
42430 {
42431 arg3 = &temp3;
42432 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42433 }
42434 {
42435 arg4 = &temp4;
42436 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42437 }
42438 {
42439 arg5 = (int)(SWIG_As_int(obj4));
42440 if (SWIG_arg_fail(5)) SWIG_fail;
42441 }
42442 {
42443 arg6 = (int)(SWIG_As_int(obj5));
42444 if (SWIG_arg_fail(6)) SWIG_fail;
42445 }
42446 if (obj6) {
42447 arg7 = obj6;
42448 }
42449 {
42450 PyThreadState* __tstate = wxPyBeginAllowThreads();
42451 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42452
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42457 return resultobj;
42458 fail:
42459 return NULL;
42460 }
42461
42462
42463 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42464 PyObject *resultobj;
42465 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42466 wxGBPosition result;
42467 PyObject * obj0 = 0 ;
42468 char *kwnames[] = {
42469 (char *) "self", NULL
42470 };
42471
42472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42474 if (SWIG_arg_fail(1)) SWIG_fail;
42475 {
42476 PyThreadState* __tstate = wxPyBeginAllowThreads();
42477 result = ((wxGBSizerItem const *)arg1)->GetPos();
42478
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 {
42483 wxGBPosition * resultptr;
42484 resultptr = new wxGBPosition((wxGBPosition &)(result));
42485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42486 }
42487 return resultobj;
42488 fail:
42489 return NULL;
42490 }
42491
42492
42493 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42494 PyObject *resultobj;
42495 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42496 wxGBSpan result;
42497 PyObject * obj0 = 0 ;
42498 char *kwnames[] = {
42499 (char *) "self", NULL
42500 };
42501
42502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42504 if (SWIG_arg_fail(1)) SWIG_fail;
42505 {
42506 PyThreadState* __tstate = wxPyBeginAllowThreads();
42507 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42508
42509 wxPyEndAllowThreads(__tstate);
42510 if (PyErr_Occurred()) SWIG_fail;
42511 }
42512 {
42513 wxGBSpan * resultptr;
42514 resultptr = new wxGBSpan((wxGBSpan &)(result));
42515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42516 }
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42524 PyObject *resultobj;
42525 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42526 wxGBPosition *arg2 = 0 ;
42527 bool result;
42528 wxGBPosition temp2 ;
42529 PyObject * obj0 = 0 ;
42530 PyObject * obj1 = 0 ;
42531 char *kwnames[] = {
42532 (char *) "self",(char *) "pos", NULL
42533 };
42534
42535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42537 if (SWIG_arg_fail(1)) SWIG_fail;
42538 {
42539 arg2 = &temp2;
42540 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42541 }
42542 {
42543 PyThreadState* __tstate = wxPyBeginAllowThreads();
42544 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42545
42546 wxPyEndAllowThreads(__tstate);
42547 if (PyErr_Occurred()) SWIG_fail;
42548 }
42549 {
42550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42551 }
42552 return resultobj;
42553 fail:
42554 return NULL;
42555 }
42556
42557
42558 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42559 PyObject *resultobj;
42560 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42561 wxGBSpan *arg2 = 0 ;
42562 bool result;
42563 wxGBSpan temp2 ;
42564 PyObject * obj0 = 0 ;
42565 PyObject * obj1 = 0 ;
42566 char *kwnames[] = {
42567 (char *) "self",(char *) "span", NULL
42568 };
42569
42570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42572 if (SWIG_arg_fail(1)) SWIG_fail;
42573 {
42574 arg2 = &temp2;
42575 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42576 }
42577 {
42578 PyThreadState* __tstate = wxPyBeginAllowThreads();
42579 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42580
42581 wxPyEndAllowThreads(__tstate);
42582 if (PyErr_Occurred()) SWIG_fail;
42583 }
42584 {
42585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42586 }
42587 return resultobj;
42588 fail:
42589 return NULL;
42590 }
42591
42592
42593 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42594 PyObject *resultobj;
42595 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42596 wxGBSizerItem *arg2 = 0 ;
42597 bool result;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 char *kwnames[] = {
42601 (char *) "self",(char *) "other", NULL
42602 };
42603
42604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42606 if (SWIG_arg_fail(1)) SWIG_fail;
42607 {
42608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42609 if (SWIG_arg_fail(2)) SWIG_fail;
42610 if (arg2 == NULL) {
42611 SWIG_null_ref("wxGBSizerItem");
42612 }
42613 if (SWIG_arg_fail(2)) SWIG_fail;
42614 }
42615 {
42616 PyThreadState* __tstate = wxPyBeginAllowThreads();
42617 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42618
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42624 }
42625 return resultobj;
42626 fail:
42627 return NULL;
42628 }
42629
42630
42631 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42632 PyObject *resultobj;
42633 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42634 wxGBPosition *arg2 = 0 ;
42635 wxGBSpan *arg3 = 0 ;
42636 bool result;
42637 wxGBPosition temp2 ;
42638 wxGBSpan temp3 ;
42639 PyObject * obj0 = 0 ;
42640 PyObject * obj1 = 0 ;
42641 PyObject * obj2 = 0 ;
42642 char *kwnames[] = {
42643 (char *) "self",(char *) "pos",(char *) "span", NULL
42644 };
42645
42646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42648 if (SWIG_arg_fail(1)) SWIG_fail;
42649 {
42650 arg2 = &temp2;
42651 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42652 }
42653 {
42654 arg3 = &temp3;
42655 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42656 }
42657 {
42658 PyThreadState* __tstate = wxPyBeginAllowThreads();
42659 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42660
42661 wxPyEndAllowThreads(__tstate);
42662 if (PyErr_Occurred()) SWIG_fail;
42663 }
42664 {
42665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42666 }
42667 return resultobj;
42668 fail:
42669 return NULL;
42670 }
42671
42672
42673 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42674 PyObject *resultobj;
42675 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42676 wxGBPosition result;
42677 PyObject * obj0 = 0 ;
42678 char *kwnames[] = {
42679 (char *) "self", NULL
42680 };
42681
42682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42684 if (SWIG_arg_fail(1)) SWIG_fail;
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = wxGBSizerItem_GetEndPos(arg1);
42688
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 wxGBPosition * resultptr;
42694 resultptr = new wxGBPosition((wxGBPosition &)(result));
42695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42696 }
42697 return resultobj;
42698 fail:
42699 return NULL;
42700 }
42701
42702
42703 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42704 PyObject *resultobj;
42705 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42706 wxGridBagSizer *result;
42707 PyObject * obj0 = 0 ;
42708 char *kwnames[] = {
42709 (char *) "self", NULL
42710 };
42711
42712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(1)) SWIG_fail;
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42718
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42730 PyObject *resultobj;
42731 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42732 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42733 PyObject * obj0 = 0 ;
42734 PyObject * obj1 = 0 ;
42735 char *kwnames[] = {
42736 (char *) "self",(char *) "sizer", NULL
42737 };
42738
42739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42741 if (SWIG_arg_fail(1)) SWIG_fail;
42742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42743 if (SWIG_arg_fail(2)) SWIG_fail;
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 (arg1)->SetGBSizer(arg2);
42747
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 Py_INCREF(Py_None); resultobj = Py_None;
42752 return resultobj;
42753 fail:
42754 return NULL;
42755 }
42756
42757
42758 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42759 PyObject *obj;
42760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42761 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42762 Py_INCREF(obj);
42763 return Py_BuildValue((char *)"");
42764 }
42765 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42766 PyObject *resultobj;
42767 int arg1 = (int) 0 ;
42768 int arg2 = (int) 0 ;
42769 wxGridBagSizer *result;
42770 PyObject * obj0 = 0 ;
42771 PyObject * obj1 = 0 ;
42772 char *kwnames[] = {
42773 (char *) "vgap",(char *) "hgap", NULL
42774 };
42775
42776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42777 if (obj0) {
42778 {
42779 arg1 = (int)(SWIG_As_int(obj0));
42780 if (SWIG_arg_fail(1)) SWIG_fail;
42781 }
42782 }
42783 if (obj1) {
42784 {
42785 arg2 = (int)(SWIG_As_int(obj1));
42786 if (SWIG_arg_fail(2)) SWIG_fail;
42787 }
42788 }
42789 {
42790 PyThreadState* __tstate = wxPyBeginAllowThreads();
42791 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42792
42793 wxPyEndAllowThreads(__tstate);
42794 if (PyErr_Occurred()) SWIG_fail;
42795 }
42796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42804 PyObject *resultobj;
42805 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42806 PyObject *arg2 = (PyObject *) 0 ;
42807 wxGBPosition *arg3 = 0 ;
42808 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42809 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42810 int arg5 = (int) 0 ;
42811 int arg6 = (int) 0 ;
42812 PyObject *arg7 = (PyObject *) NULL ;
42813 wxGBSizerItem *result;
42814 wxGBPosition temp3 ;
42815 wxGBSpan temp4 ;
42816 PyObject * obj0 = 0 ;
42817 PyObject * obj1 = 0 ;
42818 PyObject * obj2 = 0 ;
42819 PyObject * obj3 = 0 ;
42820 PyObject * obj4 = 0 ;
42821 PyObject * obj5 = 0 ;
42822 PyObject * obj6 = 0 ;
42823 char *kwnames[] = {
42824 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42825 };
42826
42827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42829 if (SWIG_arg_fail(1)) SWIG_fail;
42830 arg2 = obj1;
42831 {
42832 arg3 = &temp3;
42833 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42834 }
42835 if (obj3) {
42836 {
42837 arg4 = &temp4;
42838 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42839 }
42840 }
42841 if (obj4) {
42842 {
42843 arg5 = (int)(SWIG_As_int(obj4));
42844 if (SWIG_arg_fail(5)) SWIG_fail;
42845 }
42846 }
42847 if (obj5) {
42848 {
42849 arg6 = (int)(SWIG_As_int(obj5));
42850 if (SWIG_arg_fail(6)) SWIG_fail;
42851 }
42852 }
42853 if (obj6) {
42854 arg7 = obj6;
42855 }
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42859
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42864 return resultobj;
42865 fail:
42866 return NULL;
42867 }
42868
42869
42870 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42871 PyObject *resultobj;
42872 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42873 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42874 wxGBSizerItem *result;
42875 PyObject * obj0 = 0 ;
42876 PyObject * obj1 = 0 ;
42877 char *kwnames[] = {
42878 (char *) "self",(char *) "item", NULL
42879 };
42880
42881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42883 if (SWIG_arg_fail(1)) SWIG_fail;
42884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42885 if (SWIG_arg_fail(2)) SWIG_fail;
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42889
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42894 return resultobj;
42895 fail:
42896 return NULL;
42897 }
42898
42899
42900 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42901 PyObject *resultobj;
42902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42903 int arg2 ;
42904 int arg3 ;
42905 wxSize result;
42906 PyObject * obj0 = 0 ;
42907 PyObject * obj1 = 0 ;
42908 PyObject * obj2 = 0 ;
42909 char *kwnames[] = {
42910 (char *) "self",(char *) "row",(char *) "col", NULL
42911 };
42912
42913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42915 if (SWIG_arg_fail(1)) SWIG_fail;
42916 {
42917 arg2 = (int)(SWIG_As_int(obj1));
42918 if (SWIG_arg_fail(2)) SWIG_fail;
42919 }
42920 {
42921 arg3 = (int)(SWIG_As_int(obj2));
42922 if (SWIG_arg_fail(3)) SWIG_fail;
42923 }
42924 {
42925 PyThreadState* __tstate = wxPyBeginAllowThreads();
42926 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42927
42928 wxPyEndAllowThreads(__tstate);
42929 if (PyErr_Occurred()) SWIG_fail;
42930 }
42931 {
42932 wxSize * resultptr;
42933 resultptr = new wxSize((wxSize &)(result));
42934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42935 }
42936 return resultobj;
42937 fail:
42938 return NULL;
42939 }
42940
42941
42942 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42943 PyObject *resultobj;
42944 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42945 wxSize result;
42946 PyObject * obj0 = 0 ;
42947 char *kwnames[] = {
42948 (char *) "self", NULL
42949 };
42950
42951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42953 if (SWIG_arg_fail(1)) SWIG_fail;
42954 {
42955 PyThreadState* __tstate = wxPyBeginAllowThreads();
42956 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42957
42958 wxPyEndAllowThreads(__tstate);
42959 if (PyErr_Occurred()) SWIG_fail;
42960 }
42961 {
42962 wxSize * resultptr;
42963 resultptr = new wxSize((wxSize &)(result));
42964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42965 }
42966 return resultobj;
42967 fail:
42968 return NULL;
42969 }
42970
42971
42972 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42973 PyObject *resultobj;
42974 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42975 wxSize *arg2 = 0 ;
42976 wxSize temp2 ;
42977 PyObject * obj0 = 0 ;
42978 PyObject * obj1 = 0 ;
42979 char *kwnames[] = {
42980 (char *) "self",(char *) "sz", NULL
42981 };
42982
42983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42985 if (SWIG_arg_fail(1)) SWIG_fail;
42986 {
42987 arg2 = &temp2;
42988 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42989 }
42990 {
42991 PyThreadState* __tstate = wxPyBeginAllowThreads();
42992 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42993
42994 wxPyEndAllowThreads(__tstate);
42995 if (PyErr_Occurred()) SWIG_fail;
42996 }
42997 Py_INCREF(Py_None); resultobj = Py_None;
42998 return resultobj;
42999 fail:
43000 return NULL;
43001 }
43002
43003
43004 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43005 PyObject *resultobj;
43006 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43007 wxWindow *arg2 = (wxWindow *) 0 ;
43008 wxGBPosition result;
43009 PyObject * obj0 = 0 ;
43010 PyObject * obj1 = 0 ;
43011
43012 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43014 if (SWIG_arg_fail(1)) SWIG_fail;
43015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43016 if (SWIG_arg_fail(2)) SWIG_fail;
43017 {
43018 PyThreadState* __tstate = wxPyBeginAllowThreads();
43019 result = (arg1)->GetItemPosition(arg2);
43020
43021 wxPyEndAllowThreads(__tstate);
43022 if (PyErr_Occurred()) SWIG_fail;
43023 }
43024 {
43025 wxGBPosition * resultptr;
43026 resultptr = new wxGBPosition((wxGBPosition &)(result));
43027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43028 }
43029 return resultobj;
43030 fail:
43031 return NULL;
43032 }
43033
43034
43035 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43036 PyObject *resultobj;
43037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43038 wxSizer *arg2 = (wxSizer *) 0 ;
43039 wxGBPosition result;
43040 PyObject * obj0 = 0 ;
43041 PyObject * obj1 = 0 ;
43042
43043 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43045 if (SWIG_arg_fail(1)) SWIG_fail;
43046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43047 if (SWIG_arg_fail(2)) SWIG_fail;
43048 {
43049 PyThreadState* __tstate = wxPyBeginAllowThreads();
43050 result = (arg1)->GetItemPosition(arg2);
43051
43052 wxPyEndAllowThreads(__tstate);
43053 if (PyErr_Occurred()) SWIG_fail;
43054 }
43055 {
43056 wxGBPosition * resultptr;
43057 resultptr = new wxGBPosition((wxGBPosition &)(result));
43058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43059 }
43060 return resultobj;
43061 fail:
43062 return NULL;
43063 }
43064
43065
43066 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43067 PyObject *resultobj;
43068 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43069 size_t arg2 ;
43070 wxGBPosition result;
43071 PyObject * obj0 = 0 ;
43072 PyObject * obj1 = 0 ;
43073
43074 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43076 if (SWIG_arg_fail(1)) SWIG_fail;
43077 {
43078 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43079 if (SWIG_arg_fail(2)) SWIG_fail;
43080 }
43081 {
43082 PyThreadState* __tstate = wxPyBeginAllowThreads();
43083 result = (arg1)->GetItemPosition(arg2);
43084
43085 wxPyEndAllowThreads(__tstate);
43086 if (PyErr_Occurred()) SWIG_fail;
43087 }
43088 {
43089 wxGBPosition * resultptr;
43090 resultptr = new wxGBPosition((wxGBPosition &)(result));
43091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43092 }
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43100 int argc;
43101 PyObject *argv[3];
43102 int ii;
43103
43104 argc = PyObject_Length(args);
43105 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43106 argv[ii] = PyTuple_GetItem(args,ii);
43107 }
43108 if (argc == 2) {
43109 int _v;
43110 {
43111 void *ptr;
43112 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43113 _v = 0;
43114 PyErr_Clear();
43115 } else {
43116 _v = 1;
43117 }
43118 }
43119 if (_v) {
43120 {
43121 void *ptr;
43122 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43123 _v = 0;
43124 PyErr_Clear();
43125 } else {
43126 _v = 1;
43127 }
43128 }
43129 if (_v) {
43130 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43131 }
43132 }
43133 }
43134 if (argc == 2) {
43135 int _v;
43136 {
43137 void *ptr;
43138 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43139 _v = 0;
43140 PyErr_Clear();
43141 } else {
43142 _v = 1;
43143 }
43144 }
43145 if (_v) {
43146 {
43147 void *ptr;
43148 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43149 _v = 0;
43150 PyErr_Clear();
43151 } else {
43152 _v = 1;
43153 }
43154 }
43155 if (_v) {
43156 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43157 }
43158 }
43159 }
43160 if (argc == 2) {
43161 int _v;
43162 {
43163 void *ptr;
43164 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43165 _v = 0;
43166 PyErr_Clear();
43167 } else {
43168 _v = 1;
43169 }
43170 }
43171 if (_v) {
43172 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43173 if (_v) {
43174 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43175 }
43176 }
43177 }
43178
43179 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43180 return NULL;
43181 }
43182
43183
43184 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43185 PyObject *resultobj;
43186 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43187 wxWindow *arg2 = (wxWindow *) 0 ;
43188 wxGBPosition *arg3 = 0 ;
43189 bool result;
43190 wxGBPosition temp3 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 PyObject * obj2 = 0 ;
43194
43195 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43197 if (SWIG_arg_fail(1)) SWIG_fail;
43198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43199 if (SWIG_arg_fail(2)) SWIG_fail;
43200 {
43201 arg3 = &temp3;
43202 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43203 }
43204 {
43205 PyThreadState* __tstate = wxPyBeginAllowThreads();
43206 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43207
43208 wxPyEndAllowThreads(__tstate);
43209 if (PyErr_Occurred()) SWIG_fail;
43210 }
43211 {
43212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43213 }
43214 return resultobj;
43215 fail:
43216 return NULL;
43217 }
43218
43219
43220 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43221 PyObject *resultobj;
43222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43223 wxSizer *arg2 = (wxSizer *) 0 ;
43224 wxGBPosition *arg3 = 0 ;
43225 bool result;
43226 wxGBPosition temp3 ;
43227 PyObject * obj0 = 0 ;
43228 PyObject * obj1 = 0 ;
43229 PyObject * obj2 = 0 ;
43230
43231 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43233 if (SWIG_arg_fail(1)) SWIG_fail;
43234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43235 if (SWIG_arg_fail(2)) SWIG_fail;
43236 {
43237 arg3 = &temp3;
43238 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43239 }
43240 {
43241 PyThreadState* __tstate = wxPyBeginAllowThreads();
43242 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43243
43244 wxPyEndAllowThreads(__tstate);
43245 if (PyErr_Occurred()) SWIG_fail;
43246 }
43247 {
43248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43249 }
43250 return resultobj;
43251 fail:
43252 return NULL;
43253 }
43254
43255
43256 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43257 PyObject *resultobj;
43258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43259 size_t arg2 ;
43260 wxGBPosition *arg3 = 0 ;
43261 bool result;
43262 wxGBPosition temp3 ;
43263 PyObject * obj0 = 0 ;
43264 PyObject * obj1 = 0 ;
43265 PyObject * obj2 = 0 ;
43266
43267 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43269 if (SWIG_arg_fail(1)) SWIG_fail;
43270 {
43271 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43272 if (SWIG_arg_fail(2)) SWIG_fail;
43273 }
43274 {
43275 arg3 = &temp3;
43276 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43277 }
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43281
43282 wxPyEndAllowThreads(__tstate);
43283 if (PyErr_Occurred()) SWIG_fail;
43284 }
43285 {
43286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43287 }
43288 return resultobj;
43289 fail:
43290 return NULL;
43291 }
43292
43293
43294 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43295 int argc;
43296 PyObject *argv[4];
43297 int ii;
43298
43299 argc = PyObject_Length(args);
43300 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43301 argv[ii] = PyTuple_GetItem(args,ii);
43302 }
43303 if (argc == 3) {
43304 int _v;
43305 {
43306 void *ptr;
43307 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43308 _v = 0;
43309 PyErr_Clear();
43310 } else {
43311 _v = 1;
43312 }
43313 }
43314 if (_v) {
43315 {
43316 void *ptr;
43317 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43318 _v = 0;
43319 PyErr_Clear();
43320 } else {
43321 _v = 1;
43322 }
43323 }
43324 if (_v) {
43325 {
43326 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43327 }
43328 if (_v) {
43329 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43330 }
43331 }
43332 }
43333 }
43334 if (argc == 3) {
43335 int _v;
43336 {
43337 void *ptr;
43338 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43339 _v = 0;
43340 PyErr_Clear();
43341 } else {
43342 _v = 1;
43343 }
43344 }
43345 if (_v) {
43346 {
43347 void *ptr;
43348 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43349 _v = 0;
43350 PyErr_Clear();
43351 } else {
43352 _v = 1;
43353 }
43354 }
43355 if (_v) {
43356 {
43357 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43358 }
43359 if (_v) {
43360 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43361 }
43362 }
43363 }
43364 }
43365 if (argc == 3) {
43366 int _v;
43367 {
43368 void *ptr;
43369 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43370 _v = 0;
43371 PyErr_Clear();
43372 } else {
43373 _v = 1;
43374 }
43375 }
43376 if (_v) {
43377 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43378 if (_v) {
43379 {
43380 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43381 }
43382 if (_v) {
43383 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43384 }
43385 }
43386 }
43387 }
43388
43389 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43390 return NULL;
43391 }
43392
43393
43394 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43395 PyObject *resultobj;
43396 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43397 wxWindow *arg2 = (wxWindow *) 0 ;
43398 wxGBSpan result;
43399 PyObject * obj0 = 0 ;
43400 PyObject * obj1 = 0 ;
43401
43402 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43404 if (SWIG_arg_fail(1)) SWIG_fail;
43405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43406 if (SWIG_arg_fail(2)) SWIG_fail;
43407 {
43408 PyThreadState* __tstate = wxPyBeginAllowThreads();
43409 result = (arg1)->GetItemSpan(arg2);
43410
43411 wxPyEndAllowThreads(__tstate);
43412 if (PyErr_Occurred()) SWIG_fail;
43413 }
43414 {
43415 wxGBSpan * resultptr;
43416 resultptr = new wxGBSpan((wxGBSpan &)(result));
43417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43418 }
43419 return resultobj;
43420 fail:
43421 return NULL;
43422 }
43423
43424
43425 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43426 PyObject *resultobj;
43427 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43428 wxSizer *arg2 = (wxSizer *) 0 ;
43429 wxGBSpan result;
43430 PyObject * obj0 = 0 ;
43431 PyObject * obj1 = 0 ;
43432
43433 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43435 if (SWIG_arg_fail(1)) SWIG_fail;
43436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43437 if (SWIG_arg_fail(2)) SWIG_fail;
43438 {
43439 PyThreadState* __tstate = wxPyBeginAllowThreads();
43440 result = (arg1)->GetItemSpan(arg2);
43441
43442 wxPyEndAllowThreads(__tstate);
43443 if (PyErr_Occurred()) SWIG_fail;
43444 }
43445 {
43446 wxGBSpan * resultptr;
43447 resultptr = new wxGBSpan((wxGBSpan &)(result));
43448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43449 }
43450 return resultobj;
43451 fail:
43452 return NULL;
43453 }
43454
43455
43456 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43457 PyObject *resultobj;
43458 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43459 size_t arg2 ;
43460 wxGBSpan result;
43461 PyObject * obj0 = 0 ;
43462 PyObject * obj1 = 0 ;
43463
43464 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43466 if (SWIG_arg_fail(1)) SWIG_fail;
43467 {
43468 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43469 if (SWIG_arg_fail(2)) SWIG_fail;
43470 }
43471 {
43472 PyThreadState* __tstate = wxPyBeginAllowThreads();
43473 result = (arg1)->GetItemSpan(arg2);
43474
43475 wxPyEndAllowThreads(__tstate);
43476 if (PyErr_Occurred()) SWIG_fail;
43477 }
43478 {
43479 wxGBSpan * resultptr;
43480 resultptr = new wxGBSpan((wxGBSpan &)(result));
43481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43482 }
43483 return resultobj;
43484 fail:
43485 return NULL;
43486 }
43487
43488
43489 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43490 int argc;
43491 PyObject *argv[3];
43492 int ii;
43493
43494 argc = PyObject_Length(args);
43495 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43496 argv[ii] = PyTuple_GetItem(args,ii);
43497 }
43498 if (argc == 2) {
43499 int _v;
43500 {
43501 void *ptr;
43502 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43503 _v = 0;
43504 PyErr_Clear();
43505 } else {
43506 _v = 1;
43507 }
43508 }
43509 if (_v) {
43510 {
43511 void *ptr;
43512 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43513 _v = 0;
43514 PyErr_Clear();
43515 } else {
43516 _v = 1;
43517 }
43518 }
43519 if (_v) {
43520 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43521 }
43522 }
43523 }
43524 if (argc == 2) {
43525 int _v;
43526 {
43527 void *ptr;
43528 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43529 _v = 0;
43530 PyErr_Clear();
43531 } else {
43532 _v = 1;
43533 }
43534 }
43535 if (_v) {
43536 {
43537 void *ptr;
43538 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43539 _v = 0;
43540 PyErr_Clear();
43541 } else {
43542 _v = 1;
43543 }
43544 }
43545 if (_v) {
43546 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43547 }
43548 }
43549 }
43550 if (argc == 2) {
43551 int _v;
43552 {
43553 void *ptr;
43554 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43555 _v = 0;
43556 PyErr_Clear();
43557 } else {
43558 _v = 1;
43559 }
43560 }
43561 if (_v) {
43562 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43563 if (_v) {
43564 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43565 }
43566 }
43567 }
43568
43569 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43570 return NULL;
43571 }
43572
43573
43574 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43575 PyObject *resultobj;
43576 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43577 wxWindow *arg2 = (wxWindow *) 0 ;
43578 wxGBSpan *arg3 = 0 ;
43579 bool result;
43580 wxGBSpan temp3 ;
43581 PyObject * obj0 = 0 ;
43582 PyObject * obj1 = 0 ;
43583 PyObject * obj2 = 0 ;
43584
43585 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43587 if (SWIG_arg_fail(1)) SWIG_fail;
43588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43589 if (SWIG_arg_fail(2)) SWIG_fail;
43590 {
43591 arg3 = &temp3;
43592 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43593 }
43594 {
43595 PyThreadState* __tstate = wxPyBeginAllowThreads();
43596 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43597
43598 wxPyEndAllowThreads(__tstate);
43599 if (PyErr_Occurred()) SWIG_fail;
43600 }
43601 {
43602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43603 }
43604 return resultobj;
43605 fail:
43606 return NULL;
43607 }
43608
43609
43610 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43611 PyObject *resultobj;
43612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43613 wxSizer *arg2 = (wxSizer *) 0 ;
43614 wxGBSpan *arg3 = 0 ;
43615 bool result;
43616 wxGBSpan temp3 ;
43617 PyObject * obj0 = 0 ;
43618 PyObject * obj1 = 0 ;
43619 PyObject * obj2 = 0 ;
43620
43621 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43623 if (SWIG_arg_fail(1)) SWIG_fail;
43624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43625 if (SWIG_arg_fail(2)) SWIG_fail;
43626 {
43627 arg3 = &temp3;
43628 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43629 }
43630 {
43631 PyThreadState* __tstate = wxPyBeginAllowThreads();
43632 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43633
43634 wxPyEndAllowThreads(__tstate);
43635 if (PyErr_Occurred()) SWIG_fail;
43636 }
43637 {
43638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43639 }
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43647 PyObject *resultobj;
43648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43649 size_t arg2 ;
43650 wxGBSpan *arg3 = 0 ;
43651 bool result;
43652 wxGBSpan temp3 ;
43653 PyObject * obj0 = 0 ;
43654 PyObject * obj1 = 0 ;
43655 PyObject * obj2 = 0 ;
43656
43657 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43659 if (SWIG_arg_fail(1)) SWIG_fail;
43660 {
43661 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43662 if (SWIG_arg_fail(2)) SWIG_fail;
43663 }
43664 {
43665 arg3 = &temp3;
43666 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43667 }
43668 {
43669 PyThreadState* __tstate = wxPyBeginAllowThreads();
43670 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43671
43672 wxPyEndAllowThreads(__tstate);
43673 if (PyErr_Occurred()) SWIG_fail;
43674 }
43675 {
43676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43677 }
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43685 int argc;
43686 PyObject *argv[4];
43687 int ii;
43688
43689 argc = PyObject_Length(args);
43690 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43691 argv[ii] = PyTuple_GetItem(args,ii);
43692 }
43693 if (argc == 3) {
43694 int _v;
43695 {
43696 void *ptr;
43697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43698 _v = 0;
43699 PyErr_Clear();
43700 } else {
43701 _v = 1;
43702 }
43703 }
43704 if (_v) {
43705 {
43706 void *ptr;
43707 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43708 _v = 0;
43709 PyErr_Clear();
43710 } else {
43711 _v = 1;
43712 }
43713 }
43714 if (_v) {
43715 {
43716 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43717 }
43718 if (_v) {
43719 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43720 }
43721 }
43722 }
43723 }
43724 if (argc == 3) {
43725 int _v;
43726 {
43727 void *ptr;
43728 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43729 _v = 0;
43730 PyErr_Clear();
43731 } else {
43732 _v = 1;
43733 }
43734 }
43735 if (_v) {
43736 {
43737 void *ptr;
43738 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43739 _v = 0;
43740 PyErr_Clear();
43741 } else {
43742 _v = 1;
43743 }
43744 }
43745 if (_v) {
43746 {
43747 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43748 }
43749 if (_v) {
43750 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43751 }
43752 }
43753 }
43754 }
43755 if (argc == 3) {
43756 int _v;
43757 {
43758 void *ptr;
43759 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43760 _v = 0;
43761 PyErr_Clear();
43762 } else {
43763 _v = 1;
43764 }
43765 }
43766 if (_v) {
43767 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43768 if (_v) {
43769 {
43770 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43771 }
43772 if (_v) {
43773 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43774 }
43775 }
43776 }
43777 }
43778
43779 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43780 return NULL;
43781 }
43782
43783
43784 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43785 PyObject *resultobj;
43786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43787 wxWindow *arg2 = (wxWindow *) 0 ;
43788 wxGBSizerItem *result;
43789 PyObject * obj0 = 0 ;
43790 PyObject * obj1 = 0 ;
43791
43792 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43794 if (SWIG_arg_fail(1)) SWIG_fail;
43795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43796 if (SWIG_arg_fail(2)) SWIG_fail;
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43800
43801 wxPyEndAllowThreads(__tstate);
43802 if (PyErr_Occurred()) SWIG_fail;
43803 }
43804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43805 return resultobj;
43806 fail:
43807 return NULL;
43808 }
43809
43810
43811 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43812 PyObject *resultobj;
43813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43814 wxSizer *arg2 = (wxSizer *) 0 ;
43815 wxGBSizerItem *result;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818
43819 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43821 if (SWIG_arg_fail(1)) SWIG_fail;
43822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43823 if (SWIG_arg_fail(2)) SWIG_fail;
43824 {
43825 PyThreadState* __tstate = wxPyBeginAllowThreads();
43826 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43827
43828 wxPyEndAllowThreads(__tstate);
43829 if (PyErr_Occurred()) SWIG_fail;
43830 }
43831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43832 return resultobj;
43833 fail:
43834 return NULL;
43835 }
43836
43837
43838 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43839 int argc;
43840 PyObject *argv[3];
43841 int ii;
43842
43843 argc = PyObject_Length(args);
43844 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43845 argv[ii] = PyTuple_GetItem(args,ii);
43846 }
43847 if (argc == 2) {
43848 int _v;
43849 {
43850 void *ptr;
43851 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43852 _v = 0;
43853 PyErr_Clear();
43854 } else {
43855 _v = 1;
43856 }
43857 }
43858 if (_v) {
43859 {
43860 void *ptr;
43861 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43862 _v = 0;
43863 PyErr_Clear();
43864 } else {
43865 _v = 1;
43866 }
43867 }
43868 if (_v) {
43869 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43870 }
43871 }
43872 }
43873 if (argc == 2) {
43874 int _v;
43875 {
43876 void *ptr;
43877 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43878 _v = 0;
43879 PyErr_Clear();
43880 } else {
43881 _v = 1;
43882 }
43883 }
43884 if (_v) {
43885 {
43886 void *ptr;
43887 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43888 _v = 0;
43889 PyErr_Clear();
43890 } else {
43891 _v = 1;
43892 }
43893 }
43894 if (_v) {
43895 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43896 }
43897 }
43898 }
43899
43900 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43901 return NULL;
43902 }
43903
43904
43905 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43906 PyObject *resultobj;
43907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43908 wxGBPosition *arg2 = 0 ;
43909 wxGBSizerItem *result;
43910 wxGBPosition temp2 ;
43911 PyObject * obj0 = 0 ;
43912 PyObject * obj1 = 0 ;
43913 char *kwnames[] = {
43914 (char *) "self",(char *) "pos", NULL
43915 };
43916
43917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43919 if (SWIG_arg_fail(1)) SWIG_fail;
43920 {
43921 arg2 = &temp2;
43922 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43923 }
43924 {
43925 PyThreadState* __tstate = wxPyBeginAllowThreads();
43926 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43927
43928 wxPyEndAllowThreads(__tstate);
43929 if (PyErr_Occurred()) SWIG_fail;
43930 }
43931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43939 PyObject *resultobj;
43940 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43941 wxPoint *arg2 = 0 ;
43942 wxGBSizerItem *result;
43943 wxPoint temp2 ;
43944 PyObject * obj0 = 0 ;
43945 PyObject * obj1 = 0 ;
43946 char *kwnames[] = {
43947 (char *) "self",(char *) "pt", NULL
43948 };
43949
43950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43952 if (SWIG_arg_fail(1)) SWIG_fail;
43953 {
43954 arg2 = &temp2;
43955 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43956 }
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43960
43961 wxPyEndAllowThreads(__tstate);
43962 if (PyErr_Occurred()) SWIG_fail;
43963 }
43964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43965 return resultobj;
43966 fail:
43967 return NULL;
43968 }
43969
43970
43971 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43972 PyObject *resultobj;
43973 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43974 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43975 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43976 bool result;
43977 PyObject * obj0 = 0 ;
43978 PyObject * obj1 = 0 ;
43979 PyObject * obj2 = 0 ;
43980 char *kwnames[] = {
43981 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43982 };
43983
43984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43986 if (SWIG_arg_fail(1)) SWIG_fail;
43987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43988 if (SWIG_arg_fail(2)) SWIG_fail;
43989 if (obj2) {
43990 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43991 if (SWIG_arg_fail(3)) SWIG_fail;
43992 }
43993 {
43994 PyThreadState* __tstate = wxPyBeginAllowThreads();
43995 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43996
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 {
44001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44002 }
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44010 PyObject *resultobj;
44011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44012 wxGBPosition *arg2 = 0 ;
44013 wxGBSpan *arg3 = 0 ;
44014 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44015 bool result;
44016 wxGBPosition temp2 ;
44017 wxGBSpan temp3 ;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 PyObject * obj2 = 0 ;
44021 PyObject * obj3 = 0 ;
44022 char *kwnames[] = {
44023 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44024 };
44025
44026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44028 if (SWIG_arg_fail(1)) SWIG_fail;
44029 {
44030 arg2 = &temp2;
44031 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44032 }
44033 {
44034 arg3 = &temp3;
44035 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44036 }
44037 if (obj3) {
44038 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44039 if (SWIG_arg_fail(4)) SWIG_fail;
44040 }
44041 {
44042 PyThreadState* __tstate = wxPyBeginAllowThreads();
44043 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44044
44045 wxPyEndAllowThreads(__tstate);
44046 if (PyErr_Occurred()) SWIG_fail;
44047 }
44048 {
44049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44050 }
44051 return resultobj;
44052 fail:
44053 return NULL;
44054 }
44055
44056
44057 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44058 PyObject *obj;
44059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44060 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44061 Py_INCREF(obj);
44062 return Py_BuildValue((char *)"");
44063 }
44064 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44065 PyObject *resultobj;
44066 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44067 wxRelationship arg2 ;
44068 wxWindow *arg3 = (wxWindow *) 0 ;
44069 wxEdge arg4 ;
44070 int arg5 = (int) 0 ;
44071 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44072 PyObject * obj0 = 0 ;
44073 PyObject * obj1 = 0 ;
44074 PyObject * obj2 = 0 ;
44075 PyObject * obj3 = 0 ;
44076 PyObject * obj4 = 0 ;
44077 PyObject * obj5 = 0 ;
44078 char *kwnames[] = {
44079 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44080 };
44081
44082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44084 if (SWIG_arg_fail(1)) SWIG_fail;
44085 {
44086 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44087 if (SWIG_arg_fail(2)) SWIG_fail;
44088 }
44089 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44090 if (SWIG_arg_fail(3)) SWIG_fail;
44091 {
44092 arg4 = (wxEdge)(SWIG_As_int(obj3));
44093 if (SWIG_arg_fail(4)) SWIG_fail;
44094 }
44095 if (obj4) {
44096 {
44097 arg5 = (int)(SWIG_As_int(obj4));
44098 if (SWIG_arg_fail(5)) SWIG_fail;
44099 }
44100 }
44101 if (obj5) {
44102 {
44103 arg6 = (int)(SWIG_As_int(obj5));
44104 if (SWIG_arg_fail(6)) SWIG_fail;
44105 }
44106 }
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44110
44111 wxPyEndAllowThreads(__tstate);
44112 if (PyErr_Occurred()) SWIG_fail;
44113 }
44114 Py_INCREF(Py_None); resultobj = Py_None;
44115 return resultobj;
44116 fail:
44117 return NULL;
44118 }
44119
44120
44121 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44122 PyObject *resultobj;
44123 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44124 wxWindow *arg2 = (wxWindow *) 0 ;
44125 int arg3 = (int) 0 ;
44126 PyObject * obj0 = 0 ;
44127 PyObject * obj1 = 0 ;
44128 PyObject * obj2 = 0 ;
44129 char *kwnames[] = {
44130 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44131 };
44132
44133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44135 if (SWIG_arg_fail(1)) SWIG_fail;
44136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44137 if (SWIG_arg_fail(2)) SWIG_fail;
44138 if (obj2) {
44139 {
44140 arg3 = (int)(SWIG_As_int(obj2));
44141 if (SWIG_arg_fail(3)) SWIG_fail;
44142 }
44143 }
44144 {
44145 PyThreadState* __tstate = wxPyBeginAllowThreads();
44146 (arg1)->LeftOf(arg2,arg3);
44147
44148 wxPyEndAllowThreads(__tstate);
44149 if (PyErr_Occurred()) SWIG_fail;
44150 }
44151 Py_INCREF(Py_None); resultobj = Py_None;
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44159 PyObject *resultobj;
44160 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44161 wxWindow *arg2 = (wxWindow *) 0 ;
44162 int arg3 = (int) 0 ;
44163 PyObject * obj0 = 0 ;
44164 PyObject * obj1 = 0 ;
44165 PyObject * obj2 = 0 ;
44166 char *kwnames[] = {
44167 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44168 };
44169
44170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44172 if (SWIG_arg_fail(1)) SWIG_fail;
44173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44174 if (SWIG_arg_fail(2)) SWIG_fail;
44175 if (obj2) {
44176 {
44177 arg3 = (int)(SWIG_As_int(obj2));
44178 if (SWIG_arg_fail(3)) SWIG_fail;
44179 }
44180 }
44181 {
44182 PyThreadState* __tstate = wxPyBeginAllowThreads();
44183 (arg1)->RightOf(arg2,arg3);
44184
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 Py_INCREF(Py_None); resultobj = Py_None;
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44196 PyObject *resultobj;
44197 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44198 wxWindow *arg2 = (wxWindow *) 0 ;
44199 int arg3 = (int) 0 ;
44200 PyObject * obj0 = 0 ;
44201 PyObject * obj1 = 0 ;
44202 PyObject * obj2 = 0 ;
44203 char *kwnames[] = {
44204 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44205 };
44206
44207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44209 if (SWIG_arg_fail(1)) SWIG_fail;
44210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44211 if (SWIG_arg_fail(2)) SWIG_fail;
44212 if (obj2) {
44213 {
44214 arg3 = (int)(SWIG_As_int(obj2));
44215 if (SWIG_arg_fail(3)) SWIG_fail;
44216 }
44217 }
44218 {
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 (arg1)->Above(arg2,arg3);
44221
44222 wxPyEndAllowThreads(__tstate);
44223 if (PyErr_Occurred()) SWIG_fail;
44224 }
44225 Py_INCREF(Py_None); resultobj = Py_None;
44226 return resultobj;
44227 fail:
44228 return NULL;
44229 }
44230
44231
44232 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44233 PyObject *resultobj;
44234 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44235 wxWindow *arg2 = (wxWindow *) 0 ;
44236 int arg3 = (int) 0 ;
44237 PyObject * obj0 = 0 ;
44238 PyObject * obj1 = 0 ;
44239 PyObject * obj2 = 0 ;
44240 char *kwnames[] = {
44241 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44242 };
44243
44244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44246 if (SWIG_arg_fail(1)) SWIG_fail;
44247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44248 if (SWIG_arg_fail(2)) SWIG_fail;
44249 if (obj2) {
44250 {
44251 arg3 = (int)(SWIG_As_int(obj2));
44252 if (SWIG_arg_fail(3)) SWIG_fail;
44253 }
44254 }
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 (arg1)->Below(arg2,arg3);
44258
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 Py_INCREF(Py_None); resultobj = Py_None;
44263 return resultobj;
44264 fail:
44265 return NULL;
44266 }
44267
44268
44269 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44270 PyObject *resultobj;
44271 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44272 wxWindow *arg2 = (wxWindow *) 0 ;
44273 wxEdge arg3 ;
44274 int arg4 = (int) 0 ;
44275 PyObject * obj0 = 0 ;
44276 PyObject * obj1 = 0 ;
44277 PyObject * obj2 = 0 ;
44278 PyObject * obj3 = 0 ;
44279 char *kwnames[] = {
44280 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44281 };
44282
44283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44285 if (SWIG_arg_fail(1)) SWIG_fail;
44286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44287 if (SWIG_arg_fail(2)) SWIG_fail;
44288 {
44289 arg3 = (wxEdge)(SWIG_As_int(obj2));
44290 if (SWIG_arg_fail(3)) SWIG_fail;
44291 }
44292 if (obj3) {
44293 {
44294 arg4 = (int)(SWIG_As_int(obj3));
44295 if (SWIG_arg_fail(4)) SWIG_fail;
44296 }
44297 }
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44301
44302 wxPyEndAllowThreads(__tstate);
44303 if (PyErr_Occurred()) SWIG_fail;
44304 }
44305 Py_INCREF(Py_None); resultobj = Py_None;
44306 return resultobj;
44307 fail:
44308 return NULL;
44309 }
44310
44311
44312 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44313 PyObject *resultobj;
44314 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44315 wxWindow *arg2 = (wxWindow *) 0 ;
44316 wxEdge arg3 ;
44317 int arg4 ;
44318 PyObject * obj0 = 0 ;
44319 PyObject * obj1 = 0 ;
44320 PyObject * obj2 = 0 ;
44321 PyObject * obj3 = 0 ;
44322 char *kwnames[] = {
44323 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44324 };
44325
44326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44328 if (SWIG_arg_fail(1)) SWIG_fail;
44329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44330 if (SWIG_arg_fail(2)) SWIG_fail;
44331 {
44332 arg3 = (wxEdge)(SWIG_As_int(obj2));
44333 if (SWIG_arg_fail(3)) SWIG_fail;
44334 }
44335 {
44336 arg4 = (int)(SWIG_As_int(obj3));
44337 if (SWIG_arg_fail(4)) SWIG_fail;
44338 }
44339 {
44340 PyThreadState* __tstate = wxPyBeginAllowThreads();
44341 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44342
44343 wxPyEndAllowThreads(__tstate);
44344 if (PyErr_Occurred()) SWIG_fail;
44345 }
44346 Py_INCREF(Py_None); resultobj = Py_None;
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj;
44355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44356 int arg2 ;
44357 PyObject * obj0 = 0 ;
44358 PyObject * obj1 = 0 ;
44359 char *kwnames[] = {
44360 (char *) "self",(char *) "val", NULL
44361 };
44362
44363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44365 if (SWIG_arg_fail(1)) SWIG_fail;
44366 {
44367 arg2 = (int)(SWIG_As_int(obj1));
44368 if (SWIG_arg_fail(2)) SWIG_fail;
44369 }
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 (arg1)->Absolute(arg2);
44373
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 Py_INCREF(Py_None); resultobj = Py_None;
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44385 PyObject *resultobj;
44386 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44387 PyObject * obj0 = 0 ;
44388 char *kwnames[] = {
44389 (char *) "self", NULL
44390 };
44391
44392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44394 if (SWIG_arg_fail(1)) SWIG_fail;
44395 {
44396 PyThreadState* __tstate = wxPyBeginAllowThreads();
44397 (arg1)->Unconstrained();
44398
44399 wxPyEndAllowThreads(__tstate);
44400 if (PyErr_Occurred()) SWIG_fail;
44401 }
44402 Py_INCREF(Py_None); resultobj = Py_None;
44403 return resultobj;
44404 fail:
44405 return NULL;
44406 }
44407
44408
44409 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44410 PyObject *resultobj;
44411 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44412 PyObject * obj0 = 0 ;
44413 char *kwnames[] = {
44414 (char *) "self", NULL
44415 };
44416
44417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44419 if (SWIG_arg_fail(1)) SWIG_fail;
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->AsIs();
44423
44424 wxPyEndAllowThreads(__tstate);
44425 if (PyErr_Occurred()) SWIG_fail;
44426 }
44427 Py_INCREF(Py_None); resultobj = Py_None;
44428 return resultobj;
44429 fail:
44430 return NULL;
44431 }
44432
44433
44434 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44435 PyObject *resultobj;
44436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44437 wxWindow *result;
44438 PyObject * obj0 = 0 ;
44439 char *kwnames[] = {
44440 (char *) "self", NULL
44441 };
44442
44443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44445 if (SWIG_arg_fail(1)) SWIG_fail;
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 result = (wxWindow *)(arg1)->GetOtherWindow();
44449
44450 wxPyEndAllowThreads(__tstate);
44451 if (PyErr_Occurred()) SWIG_fail;
44452 }
44453 {
44454 resultobj = wxPyMake_wxObject(result, 0);
44455 }
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj;
44464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44465 wxEdge result;
44466 PyObject * obj0 = 0 ;
44467 char *kwnames[] = {
44468 (char *) "self", NULL
44469 };
44470
44471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44473 if (SWIG_arg_fail(1)) SWIG_fail;
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44477
44478 wxPyEndAllowThreads(__tstate);
44479 if (PyErr_Occurred()) SWIG_fail;
44480 }
44481 resultobj = SWIG_From_int((result));
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj;
44490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44491 wxEdge arg2 ;
44492 PyObject * obj0 = 0 ;
44493 PyObject * obj1 = 0 ;
44494 char *kwnames[] = {
44495 (char *) "self",(char *) "which", NULL
44496 };
44497
44498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44500 if (SWIG_arg_fail(1)) SWIG_fail;
44501 {
44502 arg2 = (wxEdge)(SWIG_As_int(obj1));
44503 if (SWIG_arg_fail(2)) SWIG_fail;
44504 }
44505 {
44506 PyThreadState* __tstate = wxPyBeginAllowThreads();
44507 (arg1)->SetEdge((wxEdge )arg2);
44508
44509 wxPyEndAllowThreads(__tstate);
44510 if (PyErr_Occurred()) SWIG_fail;
44511 }
44512 Py_INCREF(Py_None); resultobj = Py_None;
44513 return resultobj;
44514 fail:
44515 return NULL;
44516 }
44517
44518
44519 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44520 PyObject *resultobj;
44521 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44522 int arg2 ;
44523 PyObject * obj0 = 0 ;
44524 PyObject * obj1 = 0 ;
44525 char *kwnames[] = {
44526 (char *) "self",(char *) "v", NULL
44527 };
44528
44529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44531 if (SWIG_arg_fail(1)) SWIG_fail;
44532 {
44533 arg2 = (int)(SWIG_As_int(obj1));
44534 if (SWIG_arg_fail(2)) SWIG_fail;
44535 }
44536 {
44537 PyThreadState* __tstate = wxPyBeginAllowThreads();
44538 (arg1)->SetValue(arg2);
44539
44540 wxPyEndAllowThreads(__tstate);
44541 if (PyErr_Occurred()) SWIG_fail;
44542 }
44543 Py_INCREF(Py_None); resultobj = Py_None;
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj;
44552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44553 int result;
44554 PyObject * obj0 = 0 ;
44555 char *kwnames[] = {
44556 (char *) "self", NULL
44557 };
44558
44559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44561 if (SWIG_arg_fail(1)) SWIG_fail;
44562 {
44563 PyThreadState* __tstate = wxPyBeginAllowThreads();
44564 result = (int)(arg1)->GetMargin();
44565
44566 wxPyEndAllowThreads(__tstate);
44567 if (PyErr_Occurred()) SWIG_fail;
44568 }
44569 {
44570 resultobj = SWIG_From_int((int)(result));
44571 }
44572 return resultobj;
44573 fail:
44574 return NULL;
44575 }
44576
44577
44578 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44579 PyObject *resultobj;
44580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44581 int arg2 ;
44582 PyObject * obj0 = 0 ;
44583 PyObject * obj1 = 0 ;
44584 char *kwnames[] = {
44585 (char *) "self",(char *) "m", NULL
44586 };
44587
44588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(1)) SWIG_fail;
44591 {
44592 arg2 = (int)(SWIG_As_int(obj1));
44593 if (SWIG_arg_fail(2)) SWIG_fail;
44594 }
44595 {
44596 PyThreadState* __tstate = wxPyBeginAllowThreads();
44597 (arg1)->SetMargin(arg2);
44598
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 Py_INCREF(Py_None); resultobj = Py_None;
44603 return resultobj;
44604 fail:
44605 return NULL;
44606 }
44607
44608
44609 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44610 PyObject *resultobj;
44611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44612 int result;
44613 PyObject * obj0 = 0 ;
44614 char *kwnames[] = {
44615 (char *) "self", NULL
44616 };
44617
44618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44620 if (SWIG_arg_fail(1)) SWIG_fail;
44621 {
44622 PyThreadState* __tstate = wxPyBeginAllowThreads();
44623 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44624
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 {
44629 resultobj = SWIG_From_int((int)(result));
44630 }
44631 return resultobj;
44632 fail:
44633 return NULL;
44634 }
44635
44636
44637 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44638 PyObject *resultobj;
44639 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44640 int result;
44641 PyObject * obj0 = 0 ;
44642 char *kwnames[] = {
44643 (char *) "self", NULL
44644 };
44645
44646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44648 if (SWIG_arg_fail(1)) SWIG_fail;
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44652
44653 wxPyEndAllowThreads(__tstate);
44654 if (PyErr_Occurred()) SWIG_fail;
44655 }
44656 {
44657 resultobj = SWIG_From_int((int)(result));
44658 }
44659 return resultobj;
44660 fail:
44661 return NULL;
44662 }
44663
44664
44665 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44666 PyObject *resultobj;
44667 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44668 int result;
44669 PyObject * obj0 = 0 ;
44670 char *kwnames[] = {
44671 (char *) "self", NULL
44672 };
44673
44674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44676 if (SWIG_arg_fail(1)) SWIG_fail;
44677 {
44678 PyThreadState* __tstate = wxPyBeginAllowThreads();
44679 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44680
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 {
44685 resultobj = SWIG_From_int((int)(result));
44686 }
44687 return resultobj;
44688 fail:
44689 return NULL;
44690 }
44691
44692
44693 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj;
44695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44696 bool result;
44697 PyObject * obj0 = 0 ;
44698 char *kwnames[] = {
44699 (char *) "self", NULL
44700 };
44701
44702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44704 if (SWIG_arg_fail(1)) SWIG_fail;
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44708
44709 wxPyEndAllowThreads(__tstate);
44710 if (PyErr_Occurred()) SWIG_fail;
44711 }
44712 {
44713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44714 }
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj;
44723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44724 bool arg2 ;
44725 PyObject * obj0 = 0 ;
44726 PyObject * obj1 = 0 ;
44727 char *kwnames[] = {
44728 (char *) "self",(char *) "d", NULL
44729 };
44730
44731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44733 if (SWIG_arg_fail(1)) SWIG_fail;
44734 {
44735 arg2 = (bool)(SWIG_As_bool(obj1));
44736 if (SWIG_arg_fail(2)) SWIG_fail;
44737 }
44738 {
44739 PyThreadState* __tstate = wxPyBeginAllowThreads();
44740 (arg1)->SetDone(arg2);
44741
44742 wxPyEndAllowThreads(__tstate);
44743 if (PyErr_Occurred()) SWIG_fail;
44744 }
44745 Py_INCREF(Py_None); resultobj = Py_None;
44746 return resultobj;
44747 fail:
44748 return NULL;
44749 }
44750
44751
44752 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44753 PyObject *resultobj;
44754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44755 wxRelationship result;
44756 PyObject * obj0 = 0 ;
44757 char *kwnames[] = {
44758 (char *) "self", NULL
44759 };
44760
44761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44763 if (SWIG_arg_fail(1)) SWIG_fail;
44764 {
44765 PyThreadState* __tstate = wxPyBeginAllowThreads();
44766 result = (wxRelationship)(arg1)->GetRelationship();
44767
44768 wxPyEndAllowThreads(__tstate);
44769 if (PyErr_Occurred()) SWIG_fail;
44770 }
44771 resultobj = SWIG_From_int((result));
44772 return resultobj;
44773 fail:
44774 return NULL;
44775 }
44776
44777
44778 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44779 PyObject *resultobj;
44780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44781 wxRelationship arg2 ;
44782 PyObject * obj0 = 0 ;
44783 PyObject * obj1 = 0 ;
44784 char *kwnames[] = {
44785 (char *) "self",(char *) "r", NULL
44786 };
44787
44788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44790 if (SWIG_arg_fail(1)) SWIG_fail;
44791 {
44792 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44793 if (SWIG_arg_fail(2)) SWIG_fail;
44794 }
44795 {
44796 PyThreadState* __tstate = wxPyBeginAllowThreads();
44797 (arg1)->SetRelationship((wxRelationship )arg2);
44798
44799 wxPyEndAllowThreads(__tstate);
44800 if (PyErr_Occurred()) SWIG_fail;
44801 }
44802 Py_INCREF(Py_None); resultobj = Py_None;
44803 return resultobj;
44804 fail:
44805 return NULL;
44806 }
44807
44808
44809 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44810 PyObject *resultobj;
44811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44812 wxWindow *arg2 = (wxWindow *) 0 ;
44813 bool result;
44814 PyObject * obj0 = 0 ;
44815 PyObject * obj1 = 0 ;
44816 char *kwnames[] = {
44817 (char *) "self",(char *) "otherW", NULL
44818 };
44819
44820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44822 if (SWIG_arg_fail(1)) SWIG_fail;
44823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44824 if (SWIG_arg_fail(2)) SWIG_fail;
44825 {
44826 PyThreadState* __tstate = wxPyBeginAllowThreads();
44827 result = (bool)(arg1)->ResetIfWin(arg2);
44828
44829 wxPyEndAllowThreads(__tstate);
44830 if (PyErr_Occurred()) SWIG_fail;
44831 }
44832 {
44833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44834 }
44835 return resultobj;
44836 fail:
44837 return NULL;
44838 }
44839
44840
44841 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44842 PyObject *resultobj;
44843 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44844 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44845 wxWindow *arg3 = (wxWindow *) 0 ;
44846 bool result;
44847 PyObject * obj0 = 0 ;
44848 PyObject * obj1 = 0 ;
44849 PyObject * obj2 = 0 ;
44850 char *kwnames[] = {
44851 (char *) "self",(char *) "constraints",(char *) "win", NULL
44852 };
44853
44854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44856 if (SWIG_arg_fail(1)) SWIG_fail;
44857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44858 if (SWIG_arg_fail(2)) SWIG_fail;
44859 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44860 if (SWIG_arg_fail(3)) SWIG_fail;
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44864
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 {
44869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44870 }
44871 return resultobj;
44872 fail:
44873 return NULL;
44874 }
44875
44876
44877 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44878 PyObject *resultobj;
44879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44880 wxEdge arg2 ;
44881 wxWindow *arg3 = (wxWindow *) 0 ;
44882 wxWindow *arg4 = (wxWindow *) 0 ;
44883 int result;
44884 PyObject * obj0 = 0 ;
44885 PyObject * obj1 = 0 ;
44886 PyObject * obj2 = 0 ;
44887 PyObject * obj3 = 0 ;
44888 char *kwnames[] = {
44889 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44890 };
44891
44892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44894 if (SWIG_arg_fail(1)) SWIG_fail;
44895 {
44896 arg2 = (wxEdge)(SWIG_As_int(obj1));
44897 if (SWIG_arg_fail(2)) SWIG_fail;
44898 }
44899 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44900 if (SWIG_arg_fail(3)) SWIG_fail;
44901 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44902 if (SWIG_arg_fail(4)) SWIG_fail;
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44906
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 {
44911 resultobj = SWIG_From_int((int)(result));
44912 }
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44920 PyObject *obj;
44921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44922 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44923 Py_INCREF(obj);
44924 return Py_BuildValue((char *)"");
44925 }
44926 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44927 PyObject *resultobj;
44928 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44929 wxIndividualLayoutConstraint *result;
44930 PyObject * obj0 = 0 ;
44931 char *kwnames[] = {
44932 (char *) "self", NULL
44933 };
44934
44935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44937 if (SWIG_arg_fail(1)) SWIG_fail;
44938 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44939
44940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj;
44949 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44950 wxIndividualLayoutConstraint *result;
44951 PyObject * obj0 = 0 ;
44952 char *kwnames[] = {
44953 (char *) "self", NULL
44954 };
44955
44956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44958 if (SWIG_arg_fail(1)) SWIG_fail;
44959 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44960
44961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44962 return resultobj;
44963 fail:
44964 return NULL;
44965 }
44966
44967
44968 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44969 PyObject *resultobj;
44970 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44971 wxIndividualLayoutConstraint *result;
44972 PyObject * obj0 = 0 ;
44973 char *kwnames[] = {
44974 (char *) "self", NULL
44975 };
44976
44977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44979 if (SWIG_arg_fail(1)) SWIG_fail;
44980 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44981
44982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44983 return resultobj;
44984 fail:
44985 return NULL;
44986 }
44987
44988
44989 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44990 PyObject *resultobj;
44991 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44992 wxIndividualLayoutConstraint *result;
44993 PyObject * obj0 = 0 ;
44994 char *kwnames[] = {
44995 (char *) "self", NULL
44996 };
44997
44998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45000 if (SWIG_arg_fail(1)) SWIG_fail;
45001 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45002
45003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45004 return resultobj;
45005 fail:
45006 return NULL;
45007 }
45008
45009
45010 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45011 PyObject *resultobj;
45012 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45013 wxIndividualLayoutConstraint *result;
45014 PyObject * obj0 = 0 ;
45015 char *kwnames[] = {
45016 (char *) "self", NULL
45017 };
45018
45019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45021 if (SWIG_arg_fail(1)) SWIG_fail;
45022 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45023
45024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45025 return resultobj;
45026 fail:
45027 return NULL;
45028 }
45029
45030
45031 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45032 PyObject *resultobj;
45033 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45034 wxIndividualLayoutConstraint *result;
45035 PyObject * obj0 = 0 ;
45036 char *kwnames[] = {
45037 (char *) "self", NULL
45038 };
45039
45040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45042 if (SWIG_arg_fail(1)) SWIG_fail;
45043 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45044
45045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45046 return resultobj;
45047 fail:
45048 return NULL;
45049 }
45050
45051
45052 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj;
45054 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45055 wxIndividualLayoutConstraint *result;
45056 PyObject * obj0 = 0 ;
45057 char *kwnames[] = {
45058 (char *) "self", NULL
45059 };
45060
45061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45063 if (SWIG_arg_fail(1)) SWIG_fail;
45064 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45065
45066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45074 PyObject *resultobj;
45075 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45076 wxIndividualLayoutConstraint *result;
45077 PyObject * obj0 = 0 ;
45078 char *kwnames[] = {
45079 (char *) "self", NULL
45080 };
45081
45082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45084 if (SWIG_arg_fail(1)) SWIG_fail;
45085 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45086
45087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45088 return resultobj;
45089 fail:
45090 return NULL;
45091 }
45092
45093
45094 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45095 PyObject *resultobj;
45096 wxLayoutConstraints *result;
45097 char *kwnames[] = {
45098 NULL
45099 };
45100
45101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45102 {
45103 PyThreadState* __tstate = wxPyBeginAllowThreads();
45104 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45105
45106 wxPyEndAllowThreads(__tstate);
45107 if (PyErr_Occurred()) SWIG_fail;
45108 }
45109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45110 return resultobj;
45111 fail:
45112 return NULL;
45113 }
45114
45115
45116 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45117 PyObject *resultobj;
45118 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45119 wxWindow *arg2 = (wxWindow *) 0 ;
45120 int *arg3 = (int *) 0 ;
45121 bool result;
45122 int temp3 ;
45123 int res3 = 0 ;
45124 PyObject * obj0 = 0 ;
45125 PyObject * obj1 = 0 ;
45126 char *kwnames[] = {
45127 (char *) "self",(char *) "win", NULL
45128 };
45129
45130 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45133 if (SWIG_arg_fail(1)) SWIG_fail;
45134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45135 if (SWIG_arg_fail(2)) SWIG_fail;
45136 {
45137 PyThreadState* __tstate = wxPyBeginAllowThreads();
45138 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45139
45140 wxPyEndAllowThreads(__tstate);
45141 if (PyErr_Occurred()) SWIG_fail;
45142 }
45143 {
45144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45145 }
45146 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45147 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45148 return resultobj;
45149 fail:
45150 return NULL;
45151 }
45152
45153
45154 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45155 PyObject *resultobj;
45156 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45157 bool result;
45158 PyObject * obj0 = 0 ;
45159 char *kwnames[] = {
45160 (char *) "self", NULL
45161 };
45162
45163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45165 if (SWIG_arg_fail(1)) SWIG_fail;
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45169
45170 wxPyEndAllowThreads(__tstate);
45171 if (PyErr_Occurred()) SWIG_fail;
45172 }
45173 {
45174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45175 }
45176 return resultobj;
45177 fail:
45178 return NULL;
45179 }
45180
45181
45182 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45183 PyObject *obj;
45184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45185 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45186 Py_INCREF(obj);
45187 return Py_BuildValue((char *)"");
45188 }
45189 static PyMethodDef SwigMethods[] = {
45190 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45191 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45192 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45195 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45216 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45229 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45244 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45298 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45326 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45345 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45347 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45355 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45356 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45368 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45380 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45384 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45390 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45400 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45410 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45417 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45496 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45498 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45500 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45502 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45504 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45506 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45508 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45510 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45512 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45514 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45516 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45518 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45520 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45534 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45552 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45555 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45558 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45570 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45575 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45581 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45587 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45650 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45657 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45693 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45703 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45709 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45711 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45713 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45716 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45720 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45723 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45726 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45728 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45733 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45741 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45745 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45748 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45750 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45754 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45771 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45773 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45776 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45778 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45782 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45786 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45797 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45800 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45803 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45807 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45814 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45819 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45824 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45828 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45873 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45893 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45900 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45904 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45914 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46086 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46126 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46140 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46143 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46198 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46225 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46269 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46277 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46296 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46297 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46334 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46364 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46367 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46371 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46374 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46384 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46396 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46408 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46418 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46428 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46442 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46449 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46450 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46451 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46452 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46453 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46458 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46485 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46497 { NULL, NULL, 0, NULL }
46498 };
46499
46500
46501 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46502
46503 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46504 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46505 }
46506 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46507 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46508 }
46509 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46510 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46511 }
46512 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46513 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46514 }
46515 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46516 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46517 }
46518 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46519 return (void *)((wxSizer *) ((wxGridSizer *) x));
46520 }
46521 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46522 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46523 }
46524 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46525 return (void *)((wxSizer *) ((wxPySizer *) x));
46526 }
46527 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46528 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46529 }
46530 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46531 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46532 }
46533 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46534 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46535 }
46536 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46537 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46538 }
46539 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46540 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46541 }
46542 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46543 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46544 }
46545 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46546 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46547 }
46548 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46549 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46550 }
46551 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46552 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46553 }
46554 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46555 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46556 }
46557 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46558 return (void *)((wxEvent *) ((wxPyEvent *) x));
46559 }
46560 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46561 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46562 }
46563 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46564 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46565 }
46566 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46567 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46568 }
46569 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46570 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46571 }
46572 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46573 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46574 }
46575 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46576 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46577 }
46578 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46579 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46580 }
46581 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46582 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46583 }
46584 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46585 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46586 }
46587 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46588 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46589 }
46590 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46591 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46592 }
46593 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46594 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46595 }
46596 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46597 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46598 }
46599 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46600 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46601 }
46602 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46603 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46604 }
46605 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46606 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46607 }
46608 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46609 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46610 }
46611 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46612 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46613 }
46614 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46615 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46616 }
46617 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46618 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46619 }
46620 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46621 return (void *)((wxEvent *) ((wxShowEvent *) x));
46622 }
46623 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46624 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46625 }
46626 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46627 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46628 }
46629 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46630 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46631 }
46632 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46633 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46634 }
46635 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46636 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46637 }
46638 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46639 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46640 }
46641 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46642 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46643 }
46644 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46645 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46646 }
46647 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46648 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46649 }
46650 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46651 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46652 }
46653 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46654 return (void *)((wxControl *) ((wxControlWithItems *) x));
46655 }
46656 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46657 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46658 }
46659 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46660 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46661 }
46662 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46663 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46664 }
46665 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46666 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46667 }
46668 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46669 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46670 }
46671 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46672 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46673 }
46674 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46675 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46676 }
46677 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46678 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46679 }
46680 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46681 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46682 }
46683 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46684 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46685 }
46686 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46687 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46688 }
46689 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46690 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46691 }
46692 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46693 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46694 }
46695 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46696 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46697 }
46698 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46699 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46700 }
46701 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46702 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46703 }
46704 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46705 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46706 }
46707 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46708 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46709 }
46710 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46711 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46712 }
46713 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46714 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46715 }
46716 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46717 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46718 }
46719 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46720 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46721 }
46722 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46723 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46724 }
46725 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46726 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46727 }
46728 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46729 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46730 }
46731 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46732 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46733 }
46734 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46735 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46736 }
46737 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46738 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46739 }
46740 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46741 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46742 }
46743 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46744 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46745 }
46746 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46747 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46748 }
46749 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46750 return (void *)((wxObject *) ((wxSizerItem *) x));
46751 }
46752 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46753 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46754 }
46755 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46756 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46757 }
46758 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46759 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46760 }
46761 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46762 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46763 }
46764 static void *_p_wxSizerTo_p_wxObject(void *x) {
46765 return (void *)((wxObject *) ((wxSizer *) x));
46766 }
46767 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46768 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46769 }
46770 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46771 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46772 }
46773 static void *_p_wxEventTo_p_wxObject(void *x) {
46774 return (void *)((wxObject *) ((wxEvent *) x));
46775 }
46776 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46777 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46778 }
46779 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46780 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46781 }
46782 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46783 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46784 }
46785 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46786 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46787 }
46788 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46789 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46790 }
46791 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46792 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46793 }
46794 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46795 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46796 }
46797 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46798 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46799 }
46800 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46801 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46802 }
46803 static void *_p_wxControlTo_p_wxObject(void *x) {
46804 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46805 }
46806 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46807 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46808 }
46809 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46810 return (void *)((wxObject *) ((wxFSFile *) x));
46811 }
46812 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46813 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46814 }
46815 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46816 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46817 }
46818 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46819 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46820 }
46821 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46822 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46823 }
46824 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46825 return (void *)((wxObject *) ((wxMenuItem *) x));
46826 }
46827 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46828 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46829 }
46830 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46831 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46832 }
46833 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46834 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46835 }
46836 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46837 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46838 }
46839 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46840 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46841 }
46842 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46843 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46844 }
46845 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46846 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46847 }
46848 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46849 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46850 }
46851 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46852 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46853 }
46854 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46855 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46856 }
46857 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46858 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46859 }
46860 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46861 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46862 }
46863 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46864 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46865 }
46866 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46867 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46868 }
46869 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46870 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46871 }
46872 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46873 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46874 }
46875 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46876 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46877 }
46878 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46879 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46880 }
46881 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46882 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46883 }
46884 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46885 return (void *)((wxObject *) ((wxImageHandler *) x));
46886 }
46887 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46888 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46889 }
46890 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46891 return (void *)((wxObject *) ((wxEvtHandler *) x));
46892 }
46893 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46894 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46895 }
46896 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46897 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46898 }
46899 static void *_p_wxImageTo_p_wxObject(void *x) {
46900 return (void *)((wxObject *) ((wxImage *) x));
46901 }
46902 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46903 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46904 }
46905 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46906 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46907 }
46908 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46909 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46910 }
46911 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46912 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46913 }
46914 static void *_p_wxWindowTo_p_wxObject(void *x) {
46915 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46916 }
46917 static void *_p_wxMenuTo_p_wxObject(void *x) {
46918 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46919 }
46920 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46921 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46922 }
46923 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46924 return (void *)((wxObject *) ((wxFileSystem *) x));
46925 }
46926 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46927 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46928 }
46929 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46930 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46931 }
46932 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46933 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46934 }
46935 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46936 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46937 }
46938 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46939 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46940 }
46941 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46942 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46943 }
46944 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46946 }
46947 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46948 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46949 }
46950 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46951 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46952 }
46953 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46954 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46955 }
46956 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46957 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46958 }
46959 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46960 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46961 }
46962 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46963 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46964 }
46965 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46966 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46967 }
46968 static void *_p_wxControlTo_p_wxWindow(void *x) {
46969 return (void *)((wxWindow *) ((wxControl *) x));
46970 }
46971 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46972 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46973 }
46974 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46975 return (void *)((wxWindow *) ((wxMenuBar *) x));
46976 }
46977 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46978 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46979 }
46980 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46981 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46982 }
46983 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46984 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46985 }
46986 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46987 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46988 }
46989 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46990 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46991 }
46992 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46993 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46994 }
46995 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46996 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46997 }
46998 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46999 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47000 }
47001 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47002 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47003 }
47004 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47005 return (void *)((wxValidator *) ((wxPyValidator *) x));
47006 }
47007 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}};
47008 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}};
47009 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}};
47010 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}};
47011 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}};
47012 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}};
47013 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}};
47014 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}};
47015 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}};
47016 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}};
47017 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}};
47018 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}};
47019 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}};
47020 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}};
47021 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}};
47022 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}};
47023 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}};
47024 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}};
47025 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}};
47026 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}};
47027 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}};
47028 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}};
47029 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}};
47030 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}};
47031 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}};
47032 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}};
47033 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}};
47034 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}};
47035 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}};
47036 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}};
47037 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}};
47038 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}};
47039 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}};
47040 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}};
47041 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}};
47042 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}};
47043 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}};
47044 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}};
47045 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}};
47046 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}};
47047 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}};
47048 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}};
47049 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}};
47050 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}};
47051 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}};
47052 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}};
47053 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}};
47054 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}};
47055 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}};
47056 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}};
47057 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}};
47058 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}};
47059 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}};
47060 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}};
47061 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}};
47062 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}};
47063 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}};
47064 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}};
47065 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}};
47066 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}};
47067 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}};
47068 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}};
47069 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}};
47070 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}};
47071 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}};
47072 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}};
47073 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}};
47074 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}};
47075 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}};
47076 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}};
47077 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}};
47078 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}};
47079 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}};
47080 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}};
47081 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}};
47082 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}};
47083 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}};
47084 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47085 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}};
47086 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}};
47087 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}};
47088 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}};
47089 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}};
47090 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}};
47091 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}};
47092 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}};
47093 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}};
47094 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}};
47095 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}};
47096 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}};
47097 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}};
47098 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}};
47099 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}};
47100 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}};
47101 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47102 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}};
47103 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}};
47104 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}};
47105 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}};
47106 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}};
47107 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}};
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134
47135 static swig_type_info *swig_types_initial[] = {
47136 _swigt__p_wxLayoutConstraints,
47137 _swigt__p_wxRealPoint,
47138 _swigt__p_wxSizerItem,
47139 _swigt__p_wxGBSizerItem,
47140 _swigt__p_wxScrollEvent,
47141 _swigt__p_wxEventLoop,
47142 _swigt__p_wxIndividualLayoutConstraint,
47143 _swigt__p_wxSizer,
47144 _swigt__p_wxBoxSizer,
47145 _swigt__p_wxStaticBoxSizer,
47146 _swigt__p_wxGridBagSizer,
47147 _swigt__p_wxAcceleratorEntry,
47148 _swigt__p_wxUpdateUIEvent,
47149 _swigt__p_wxEvent,
47150 _swigt__p_wxMenu,
47151 _swigt__p_wxGridSizer,
47152 _swigt__p_wxFlexGridSizer,
47153 _swigt__p_wxInitDialogEvent,
47154 _swigt__p_wxItemContainer,
47155 _swigt__p_wxNcPaintEvent,
47156 _swigt__p_wxPaintEvent,
47157 _swigt__p_wxSysColourChangedEvent,
47158 _swigt__p_wxMouseCaptureChangedEvent,
47159 _swigt__p_wxDisplayChangedEvent,
47160 _swigt__p_wxPaletteChangedEvent,
47161 _swigt__p_wxControl,
47162 _swigt__p_wxFont,
47163 _swigt__p_wxMenuBarBase,
47164 _swigt__p_wxSetCursorEvent,
47165 _swigt__p_wxFSFile,
47166 _swigt__p_wxCaret,
47167 _swigt__ptrdiff_t,
47168 _swigt__std__ptrdiff_t,
47169 _swigt__p_wxRegion,
47170 _swigt__p_wxPoint2D,
47171 _swigt__p_int,
47172 _swigt__p_wxSize,
47173 _swigt__p_wxDC,
47174 _swigt__p_wxPySizer,
47175 _swigt__p_wxVisualAttributes,
47176 _swigt__p_wxNotifyEvent,
47177 _swigt__p_wxPyEvent,
47178 _swigt__p_wxPropagationDisabler,
47179 _swigt__p_form_ops_t,
47180 _swigt__p_wxAppTraits,
47181 _swigt__p_wxArrayString,
47182 _swigt__p_wxShowEvent,
47183 _swigt__p_wxToolTip,
47184 _swigt__p_wxMoveEvent,
47185 _swigt__p_wxSizeEvent,
47186 _swigt__p_wxActivateEvent,
47187 _swigt__p_wxIconizeEvent,
47188 _swigt__p_wxMaximizeEvent,
47189 _swigt__p_wxQueryNewPaletteEvent,
47190 _swigt__p_wxWindowCreateEvent,
47191 _swigt__p_wxIdleEvent,
47192 _swigt__p_wxDateEvent,
47193 _swigt__p_wxMenuItem,
47194 _swigt__p_wxStaticBox,
47195 _swigt__p_long,
47196 _swigt__p_wxDuplexMode,
47197 _swigt__p_wxTIFFHandler,
47198 _swigt__p_wxXPMHandler,
47199 _swigt__p_wxPNMHandler,
47200 _swigt__p_wxJPEGHandler,
47201 _swigt__p_wxPCXHandler,
47202 _swigt__p_wxGIFHandler,
47203 _swigt__p_wxPNGHandler,
47204 _swigt__p_wxANIHandler,
47205 _swigt__p_wxMemoryFSHandler,
47206 _swigt__p_wxZipFSHandler,
47207 _swigt__p_wxInternetFSHandler,
47208 _swigt__p_wxPyFileSystemHandler,
47209 _swigt__p_wxEvtHandler,
47210 _swigt__p_wxCURHandler,
47211 _swigt__p_wxICOHandler,
47212 _swigt__p_wxBMPHandler,
47213 _swigt__p_wxImageHandler,
47214 _swigt__p_wxFileSystemHandler,
47215 _swigt__p_wxRect,
47216 _swigt__p_wxButton,
47217 _swigt__p_wxGBSpan,
47218 _swigt__p_wxPropagateOnce,
47219 _swigt__p_wxAcceleratorTable,
47220 _swigt__p_wxStdDialogButtonSizer,
47221 _swigt__p_char,
47222 _swigt__p_wxGBPosition,
47223 _swigt__p_wxImage,
47224 _swigt__p_wxFrame,
47225 _swigt__p_wxScrollWinEvent,
47226 _swigt__p_wxPaperSize,
47227 _swigt__p_wxImageHistogram,
47228 _swigt__p_wxPoint,
47229 _swigt__p_wxCursor,
47230 _swigt__p_wxObject,
47231 _swigt__p_wxInputStream,
47232 _swigt__p_wxOutputStream,
47233 _swigt__p_wxPyInputStream,
47234 _swigt__p_wxDateTime,
47235 _swigt__p_wxKeyEvent,
47236 _swigt__p_wxNavigationKeyEvent,
47237 _swigt__p_wxWindowDestroyEvent,
47238 _swigt__p_unsigned_long,
47239 _swigt__p_wxWindow,
47240 _swigt__p_wxMenuBar,
47241 _swigt__p_wxFileSystem,
47242 _swigt__p_wxBitmap,
47243 _swigt__unsigned_int,
47244 _swigt__p_unsigned_int,
47245 _swigt__p_wxMenuEvent,
47246 _swigt__p_wxContextMenuEvent,
47247 _swigt__p_unsigned_char,
47248 _swigt__p_wxEraseEvent,
47249 _swigt__p_wxMouseEvent,
47250 _swigt__p_wxCloseEvent,
47251 _swigt__p_wxPyApp,
47252 _swigt__p_wxCommandEvent,
47253 _swigt__p_wxPyCommandEvent,
47254 _swigt__p_wxPyDropTarget,
47255 _swigt__p_wxQuantize,
47256 _swigt__p_wxChildFocusEvent,
47257 _swigt__p_wxFocusEvent,
47258 _swigt__p_wxDropFilesEvent,
47259 _swigt__p_wxControlWithItems,
47260 _swigt__p_wxColour,
47261 _swigt__p_wxValidator,
47262 _swigt__p_wxPyValidator,
47263 0
47264 };
47265
47266
47267 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47268
47269 static swig_const_info swig_const_table[] = {
47270 {0, 0, 0, 0.0, 0, 0}};
47271
47272 #ifdef __cplusplus
47273 }
47274 #endif
47275
47276
47277 #ifdef __cplusplus
47278 extern "C" {
47279 #endif
47280
47281 /* Python-specific SWIG API */
47282 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47283 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47284 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47285
47286 /* -----------------------------------------------------------------------------
47287 * global variable support code.
47288 * ----------------------------------------------------------------------------- */
47289
47290 typedef struct swig_globalvar {
47291 char *name; /* Name of global variable */
47292 PyObject *(*get_attr)(); /* Return the current value */
47293 int (*set_attr)(PyObject *); /* Set the value */
47294 struct swig_globalvar *next;
47295 } swig_globalvar;
47296
47297 typedef struct swig_varlinkobject {
47298 PyObject_HEAD
47299 swig_globalvar *vars;
47300 } swig_varlinkobject;
47301
47302 static PyObject *
47303 swig_varlink_repr(swig_varlinkobject *v) {
47304 v = v;
47305 return PyString_FromString("<Swig global variables>");
47306 }
47307
47308 static int
47309 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47310 swig_globalvar *var;
47311 flags = flags;
47312 fprintf(fp,"Swig global variables { ");
47313 for (var = v->vars; var; var=var->next) {
47314 fprintf(fp,"%s", var->name);
47315 if (var->next) fprintf(fp,", ");
47316 }
47317 fprintf(fp," }\n");
47318 return 0;
47319 }
47320
47321 static PyObject *
47322 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47323 swig_globalvar *var = v->vars;
47324 while (var) {
47325 if (strcmp(var->name,n) == 0) {
47326 return (*var->get_attr)();
47327 }
47328 var = var->next;
47329 }
47330 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47331 return NULL;
47332 }
47333
47334 static int
47335 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47336 swig_globalvar *var = v->vars;
47337 while (var) {
47338 if (strcmp(var->name,n) == 0) {
47339 return (*var->set_attr)(p);
47340 }
47341 var = var->next;
47342 }
47343 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47344 return 1;
47345 }
47346
47347 static PyTypeObject varlinktype = {
47348 PyObject_HEAD_INIT(0)
47349 0, /* Number of items in variable part (ob_size) */
47350 (char *)"swigvarlink", /* Type name (tp_name) */
47351 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47352 0, /* Itemsize (tp_itemsize) */
47353 0, /* Deallocator (tp_dealloc) */
47354 (printfunc) swig_varlink_print, /* Print (tp_print) */
47355 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47356 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47357 0, /* tp_compare */
47358 (reprfunc) swig_varlink_repr, /* tp_repr */
47359 0, /* tp_as_number */
47360 0, /* tp_as_sequence */
47361 0, /* tp_as_mapping */
47362 0, /* tp_hash */
47363 0, /* tp_call */
47364 0, /* tp_str */
47365 0, /* tp_getattro */
47366 0, /* tp_setattro */
47367 0, /* tp_as_buffer */
47368 0, /* tp_flags */
47369 0, /* tp_doc */
47370 #if PY_VERSION_HEX >= 0x02000000
47371 0, /* tp_traverse */
47372 0, /* tp_clear */
47373 #endif
47374 #if PY_VERSION_HEX >= 0x02010000
47375 0, /* tp_richcompare */
47376 0, /* tp_weaklistoffset */
47377 #endif
47378 #if PY_VERSION_HEX >= 0x02020000
47379 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47380 #endif
47381 #if PY_VERSION_HEX >= 0x02030000
47382 0, /* tp_del */
47383 #endif
47384 #ifdef COUNT_ALLOCS
47385 0,0,0,0 /* tp_alloc -> tp_next */
47386 #endif
47387 };
47388
47389 /* Create a variable linking object for use later */
47390 static PyObject *
47391 SWIG_Python_newvarlink(void) {
47392 swig_varlinkobject *result = 0;
47393 result = PyMem_NEW(swig_varlinkobject,1);
47394 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47395 result->ob_type = &varlinktype;
47396 result->vars = 0;
47397 result->ob_refcnt = 0;
47398 Py_XINCREF((PyObject *) result);
47399 return ((PyObject*) result);
47400 }
47401
47402 static void
47403 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47404 swig_varlinkobject *v;
47405 swig_globalvar *gv;
47406 v= (swig_varlinkobject *) p;
47407 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47408 gv->name = (char *) malloc(strlen(name)+1);
47409 strcpy(gv->name,name);
47410 gv->get_attr = get_attr;
47411 gv->set_attr = set_attr;
47412 gv->next = v->vars;
47413 v->vars = gv;
47414 }
47415
47416 /* -----------------------------------------------------------------------------
47417 * constants/methods manipulation
47418 * ----------------------------------------------------------------------------- */
47419
47420 /* Install Constants */
47421 static void
47422 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47423 PyObject *obj = 0;
47424 size_t i;
47425 for (i = 0; constants[i].type; i++) {
47426 switch(constants[i].type) {
47427 case SWIG_PY_INT:
47428 obj = PyInt_FromLong(constants[i].lvalue);
47429 break;
47430 case SWIG_PY_FLOAT:
47431 obj = PyFloat_FromDouble(constants[i].dvalue);
47432 break;
47433 case SWIG_PY_STRING:
47434 if (constants[i].pvalue) {
47435 obj = PyString_FromString((char *) constants[i].pvalue);
47436 } else {
47437 Py_INCREF(Py_None);
47438 obj = Py_None;
47439 }
47440 break;
47441 case SWIG_PY_POINTER:
47442 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47443 break;
47444 case SWIG_PY_BINARY:
47445 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47446 break;
47447 default:
47448 obj = 0;
47449 break;
47450 }
47451 if (obj) {
47452 PyDict_SetItemString(d,constants[i].name,obj);
47453 Py_DECREF(obj);
47454 }
47455 }
47456 }
47457
47458 /* -----------------------------------------------------------------------------*/
47459 /* Fix SwigMethods to carry the callback ptrs when needed */
47460 /* -----------------------------------------------------------------------------*/
47461
47462 static void
47463 SWIG_Python_FixMethods(PyMethodDef *methods,
47464 swig_const_info *const_table,
47465 swig_type_info **types,
47466 swig_type_info **types_initial) {
47467 size_t i;
47468 for (i = 0; methods[i].ml_name; ++i) {
47469 char *c = methods[i].ml_doc;
47470 if (c && (c = strstr(c, "swig_ptr: "))) {
47471 int j;
47472 swig_const_info *ci = 0;
47473 char *name = c + 10;
47474 for (j = 0; const_table[j].type; j++) {
47475 if (strncmp(const_table[j].name, name,
47476 strlen(const_table[j].name)) == 0) {
47477 ci = &(const_table[j]);
47478 break;
47479 }
47480 }
47481 if (ci) {
47482 size_t shift = (ci->ptype) - types;
47483 swig_type_info *ty = types_initial[shift];
47484 size_t ldoc = (c - methods[i].ml_doc);
47485 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47486 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47487 char *buff = ndoc;
47488 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47489 strncpy(buff, methods[i].ml_doc, ldoc);
47490 buff += ldoc;
47491 strncpy(buff, "swig_ptr: ", 10);
47492 buff += 10;
47493 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47494 methods[i].ml_doc = ndoc;
47495 }
47496 }
47497 }
47498 }
47499
47500 /* -----------------------------------------------------------------------------*
47501 * Initialize type list
47502 * -----------------------------------------------------------------------------*/
47503
47504 #if PY_MAJOR_VERSION < 2
47505 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47506 is copied out of Python/modsupport.c in python version 2.3.4 */
47507 static int
47508 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47509 {
47510 PyObject *dict;
47511 if (!PyModule_Check(m)) {
47512 PyErr_SetString(PyExc_TypeError,
47513 "PyModule_AddObject() needs module as first arg");
47514 return -1;
47515 }
47516 if (!o) {
47517 PyErr_SetString(PyExc_TypeError,
47518 "PyModule_AddObject() needs non-NULL value");
47519 return -1;
47520 }
47521
47522 dict = PyModule_GetDict(m);
47523 if (dict == NULL) {
47524 /* Internal error -- modules must have a dict! */
47525 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47526 PyModule_GetName(m));
47527 return -1;
47528 }
47529 if (PyDict_SetItemString(dict, name, o))
47530 return -1;
47531 Py_DECREF(o);
47532 return 0;
47533 }
47534 #endif
47535
47536 static swig_type_info **
47537 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47538 static PyMethodDef swig_empty_runtime_method_table[] = {
47539 {
47540 NULL, NULL, 0, NULL
47541 }
47542 };/* Sentinel */
47543
47544 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47545 swig_empty_runtime_method_table);
47546 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47547 if (pointer && module) {
47548 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47549 }
47550 return type_list_handle;
47551 }
47552
47553 static swig_type_info **
47554 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47555 swig_type_info **type_pointer;
47556
47557 /* first check if module already created */
47558 type_pointer = SWIG_Python_GetTypeListHandle();
47559 if (type_pointer) {
47560 return type_pointer;
47561 } else {
47562 /* create a new module and variable */
47563 return SWIG_Python_SetTypeListHandle(type_list_handle);
47564 }
47565 }
47566
47567 #ifdef __cplusplus
47568 }
47569 #endif
47570
47571 /* -----------------------------------------------------------------------------*
47572 * Partial Init method
47573 * -----------------------------------------------------------------------------*/
47574
47575 #ifdef SWIG_LINK_RUNTIME
47576 #ifdef __cplusplus
47577 extern "C"
47578 #endif
47579 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47580 #endif
47581
47582 #ifdef __cplusplus
47583 extern "C"
47584 #endif
47585 SWIGEXPORT(void) SWIG_init(void) {
47586 static PyObject *SWIG_globals = 0;
47587 static int typeinit = 0;
47588 PyObject *m, *d;
47589 int i;
47590 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47591
47592 /* Fix SwigMethods to carry the callback ptrs when needed */
47593 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47594
47595 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47596 d = PyModule_GetDict(m);
47597
47598 if (!typeinit) {
47599 #ifdef SWIG_LINK_RUNTIME
47600 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47601 #else
47602 # ifndef SWIG_STATIC_RUNTIME
47603 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47604 # endif
47605 #endif
47606 for (i = 0; swig_types_initial[i]; i++) {
47607 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47608 }
47609 typeinit = 1;
47610 }
47611 SWIG_InstallConstants(d,swig_const_table);
47612
47613
47614 #ifndef wxPyUSE_EXPORT
47615 // Make our API structure a CObject so other modules can import it
47616 // from this module.
47617 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47618 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47619 Py_XDECREF(cobj);
47620 #endif
47621
47622 {
47623 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49274 }
49275 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49276 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49277 {
49278 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49429 }
49430 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49431 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49432 {
49433 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49440 }
49441
49442 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49443
49444
49445 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49446
49447 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49448 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49449 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49450 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49451 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49452 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49453 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49454 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49455 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49456 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49457 {
49458 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49462 }
49463 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49464 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49465 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49466 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49467 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49468 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49469 {
49470 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49516 }
49517 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49518 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49519 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49520 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49521 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49522 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49523 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49524 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49525 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49526 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49527 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49528 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49529 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49530 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49531 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49532 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49533 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49534 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49535 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49536 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49537 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49538 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49539 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49540 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49541 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49542 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49543 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49544 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49545 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49546 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49547 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49548 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49549 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49550 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49551 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49552 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49553 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49554 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49555 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49556 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49557 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49558 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49559 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49560 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49561 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49562 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49563 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49564 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49565 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49566 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49567 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49568 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49569 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49570 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49571 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49572 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49573 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49574 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49575 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49576 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49577 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49578 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49579 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49580 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49581 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49582 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49583 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49584 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49585 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49586 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49587 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49588 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49589 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49590 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49591 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49592 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49593 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49594 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49595 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49596 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49597 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49598 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49599 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49600 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49601 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49602 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49603 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49604 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49605 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49606 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49607 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49608 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49609 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49610 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49611 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49612 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49613 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49614 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49615 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49616 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49617 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49618 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49619 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49620 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49621 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49622 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49623 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49624 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49625 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49626 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49627 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49628 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49629 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49630 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49631 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49632 {
49633 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49670 }
49671 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49672 {
49673 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49689 }
49690 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49691 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49692 {
49693 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49706 }
49707 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49708 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49709 {
49710 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49717 }
49718 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49719 {
49720 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49775 }
49776
49777 // Initialize threading, some globals and such
49778 __wxPyPreStart(d);
49779
49780
49781 // Although these are defined in __version__ they need to be here too so
49782 // that an assert can be done to ensure that the wxPython and the wxWindows
49783 // versions match.
49784 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49785 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49786 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49787
49788 }
49789
wxWidgets (Impactor)