]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
adding core services and increase Universal Header min req
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 PyObject* list = PyList_New(count);
2616
2617 if (!list) {
2618 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2619 return NULL;
2620 }
2621
2622 for (int i=0; i<count; i++) {
2623 PyList_SetItem(list, i, wx2PyString(files[i]));
2624 }
2625 return list;
2626 }
2627
2628
2629 static wxPyApp *new_wxPyApp(){
2630 wxPythonApp = new wxPyApp();
2631 return wxPythonApp;
2632 }
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 PyObject* GetTopLevelWindows() {
2770 return wxPy_ConvertList(&wxTopLevelWindows);
2771 }
2772
2773
2774 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2775 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2776 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2777
2778 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2779
2780 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2781 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2782 wxMenuItemList& list = self->GetMenuItems();
2783 return wxPy_ConvertList(&list);
2784 }
2785 static const wxString wxPyControlNameStr(wxControlNameStr);
2786 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2787 if (clientData) {
2788 wxPyClientData* data = new wxPyClientData(clientData);
2789 return self->Append(item, data);
2790 } else
2791 return self->Append(item);
2792 }
2793 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2794 if (clientData) {
2795 wxPyClientData* data = new wxPyClientData(clientData);
2796 return self->Insert(item, pos, data);
2797 } else
2798 return self->Insert(item, pos);
2799 }
2800 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2801 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2802 if (data) {
2803 Py_INCREF(data->m_obj);
2804 return data->m_obj;
2805 } else {
2806 Py_INCREF(Py_None);
2807 return Py_None;
2808 }
2809 }
2810 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2811 wxPyClientData* data = new wxPyClientData(clientData);
2812 self->SetClientObject(n, data);
2813 }
2814
2815
2816 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2817 wxPyUserData* data = NULL;
2818 if ( userData ) {
2819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2820 data = new wxPyUserData(userData);
2821 wxPyEndBlockThreads(blocked);
2822 }
2823 return new wxSizerItem(window, proportion, flag, border, data);
2824 }
2825 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2826 wxPyUserData* data = NULL;
2827 if ( userData ) {
2828 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2829 data = new wxPyUserData(userData);
2830 wxPyEndBlockThreads(blocked);
2831 }
2832 return new wxSizerItem(width, height, proportion, flag, border, data);
2833 }
2834 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2835 wxPyUserData* data = NULL;
2836 if ( userData ) {
2837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2838 data = new wxPyUserData(userData);
2839 wxPyEndBlockThreads(blocked);
2840 }
2841 return new wxSizerItem(sizer, proportion, flag, border, data);
2842 }
2843
2844 #include <float.h>
2845 SWIGINTERN int
2846 SWIG_CheckDoubleInRange(double value, double min_value,
2847 double max_value, const char* errmsg)
2848 {
2849 if (value < min_value) {
2850 if (errmsg) {
2851 PyErr_Format(PyExc_OverflowError,
2852 "value %g is less than %s minimum %g",
2853 value, errmsg, min_value);
2854 }
2855 return 0;
2856 } else if (value > max_value) {
2857 if (errmsg) {
2858 PyErr_Format(PyExc_OverflowError,
2859 "value %g is greater than %s maximum %g",
2860 value, errmsg, max_value);
2861 }
2862 return 0;
2863 }
2864 return 1;
2865 }
2866
2867
2868 SWIGINTERN int
2869 SWIG_AsVal_float(PyObject *obj, float *val)
2870 {
2871 const char* errmsg = val ? "float" : (char*)0;
2872 double v;
2873 if (SWIG_AsVal_double(obj, &v)) {
2874 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2875 if (val) *val = (float)(v);
2876 return 1;
2877 } else {
2878 return 0;
2879 }
2880 } else {
2881 PyErr_Clear();
2882 }
2883 if (val) {
2884 SWIG_type_error(errmsg, obj);
2885 }
2886 return 0;
2887 }
2888
2889
2890 SWIGINTERNSHORT float
2891 SWIG_As_float(PyObject* obj)
2892 {
2893 float v;
2894 if (!SWIG_AsVal_float(obj, &v)) {
2895 /*
2896 this is needed to make valgrind/purify happier.
2897 */
2898 memset((void*)&v, 0, sizeof(float));
2899 }
2900 return v;
2901 }
2902
2903
2904 SWIGINTERNSHORT int
2905 SWIG_Check_float(PyObject* obj)
2906 {
2907 return SWIG_AsVal_float(obj, (float*)0);
2908 }
2909
2910
2911 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2912 #define SWIG_From_float PyFloat_FromDouble
2913 /*@@*/
2914
2915 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2916 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2917 if (data) {
2918 Py_INCREF(data->m_obj);
2919 return data->m_obj;
2920 } else {
2921 Py_INCREF(Py_None);
2922 return Py_None;
2923 }
2924 }
2925
2926 // Figure out the type of the sizer item
2927
2928 struct wxPySizerItemInfo {
2929 wxPySizerItemInfo()
2930 : window(NULL), sizer(NULL), gotSize(false),
2931 size(wxDefaultSize), gotPos(false), pos(-1)
2932 {}
2933
2934 wxWindow* window;
2935 wxSizer* sizer;
2936 bool gotSize;
2937 wxSize size;
2938 bool gotPos;
2939 int pos;
2940 };
2941
2942 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2943
2944 wxPySizerItemInfo info;
2945 wxSize size;
2946 wxSize* sizePtr = &size;
2947
2948 // Find out what the type of the item is
2949 // try wxWindow
2950 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2951 PyErr_Clear();
2952 info.window = NULL;
2953
2954 // try wxSizer
2955 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2956 PyErr_Clear();
2957 info.sizer = NULL;
2958
2959 // try wxSize or (w,h)
2960 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2961 info.size = *sizePtr;
2962 info.gotSize = true;
2963 }
2964
2965 // or a single int
2966 if (checkIdx && PyInt_Check(item)) {
2967 info.pos = PyInt_AsLong(item);
2968 info.gotPos = true;
2969 }
2970 }
2971 }
2972
2973 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2974 // no expected type, figure out what kind of error message to generate
2975 if ( !checkSize && !checkIdx )
2976 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2977 else if ( checkSize && !checkIdx )
2978 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2979 else if ( !checkSize && checkIdx)
2980 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2981 else
2982 // can this one happen?
2983 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2984 }
2985
2986 return info;
2987 }
2988
2989 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2990 if (!self->GetClientObject())
2991 self->SetClientObject(new wxPyOORClientData(_self));
2992 }
2993 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2994
2995 wxPyUserData* data = NULL;
2996 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2997 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2998 if ( userData && (info.window || info.sizer || info.gotSize) )
2999 data = new wxPyUserData(userData);
3000 wxPyEndBlockThreads(blocked);
3001
3002 // Now call the real Add method if a valid item type was found
3003 if ( info.window )
3004 return self->Add(info.window, proportion, flag, border, data);
3005 else if ( info.sizer )
3006 return self->Add(info.sizer, proportion, flag, border, data);
3007 else if (info.gotSize)
3008 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3009 proportion, flag, border, data);
3010 else
3011 return NULL;
3012 }
3013 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3014
3015 wxPyUserData* data = NULL;
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3017 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3018 if ( userData && (info.window || info.sizer || info.gotSize) )
3019 data = new wxPyUserData(userData);
3020 wxPyEndBlockThreads(blocked);
3021
3022 // Now call the real Insert method if a valid item type was found
3023 if ( info.window )
3024 return self->Insert(before, info.window, proportion, flag, border, data);
3025 else if ( info.sizer )
3026 return self->Insert(before, info.sizer, proportion, flag, border, data);
3027 else if (info.gotSize)
3028 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3029 proportion, flag, border, data);
3030 else
3031 return NULL;
3032 }
3033 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3034
3035 wxPyUserData* data = NULL;
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3037 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3038 if ( userData && (info.window || info.sizer || info.gotSize) )
3039 data = new wxPyUserData(userData);
3040 wxPyEndBlockThreads(blocked);
3041
3042 // Now call the real Prepend method if a valid item type was found
3043 if ( info.window )
3044 return self->Prepend(info.window, proportion, flag, border, data);
3045 else if ( info.sizer )
3046 return self->Prepend(info.sizer, proportion, flag, border, data);
3047 else if (info.gotSize)
3048 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3049 proportion, flag, border, data);
3050 else
3051 return NULL;
3052 }
3053 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3054 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3055 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3056 wxPyEndBlockThreads(blocked);
3057 if ( info.window )
3058 return self->Remove(info.window);
3059 else if ( info.sizer )
3060 return self->Remove(info.sizer);
3061 else if ( info.gotPos )
3062 return self->Remove(info.pos);
3063 else
3064 return false;
3065 }
3066 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3068 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3069 wxPyEndBlockThreads(blocked);
3070 if ( info.window )
3071 return self->Detach(info.window);
3072 else if ( info.sizer )
3073 return self->Detach(info.sizer);
3074 else if ( info.gotPos )
3075 return self->Detach(info.pos);
3076 else
3077 return false;
3078 }
3079 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3080 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3081 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3082 wxPyEndBlockThreads(blocked);
3083 if ( info.window )
3084 return self->GetItem(info.window);
3085 else if ( info.sizer )
3086 return self->GetItem(info.sizer);
3087 else if ( info.gotPos )
3088 return self->GetItem(info.pos);
3089 else
3090 return NULL;
3091 }
3092 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3093 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3094 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3095 wxPyEndBlockThreads(blocked);
3096 if ( info.window )
3097 self->SetItemMinSize(info.window, size);
3098 else if ( info.sizer )
3099 self->SetItemMinSize(info.sizer, size);
3100 else if ( info.gotPos )
3101 self->SetItemMinSize(info.pos, size);
3102 }
3103 static PyObject *wxSizer_GetChildren(wxSizer *self){
3104 wxSizerItemList& list = self->GetChildren();
3105 return wxPy_ConvertList(&list);
3106 }
3107 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3110 wxPyEndBlockThreads(blocked);
3111 if ( info.window )
3112 return self->Show(info.window, show, recursive);
3113 else if ( info.sizer )
3114 return self->Show(info.sizer, show, recursive);
3115 else if ( info.gotPos )
3116 return self->Show(info.pos, show);
3117 else
3118 return false;
3119 }
3120 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3121 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3122 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3123 wxPyEndBlockThreads(blocked);
3124 if ( info.window )
3125 return self->IsShown(info.window);
3126 else if ( info.sizer )
3127 return self->IsShown(info.sizer);
3128 else if ( info.gotPos )
3129 return self->IsShown(info.pos);
3130 else
3131 return false;
3132 }
3133
3134 // See pyclasses.h
3135 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3136 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3137 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3138
3139
3140
3141
3142 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3143 {
3144 if (source == Py_None) {
3145 **obj = wxGBPosition(-1,-1);
3146 return true;
3147 }
3148 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3149 }
3150
3151 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3152 {
3153 if (source == Py_None) {
3154 **obj = wxGBSpan(-1,-1);
3155 return true;
3156 }
3157 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3158 }
3159
3160
3161 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3162 self->SetRow(row);
3163 self->SetCol(col);
3164 }
3165 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3167 PyObject* tup = PyTuple_New(2);
3168 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3169 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3170 wxPyEndBlockThreads(blocked);
3171 return tup;
3172 }
3173 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3174 self->SetRowspan(rowspan);
3175 self->SetColspan(colspan);
3176 }
3177 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 PyObject* tup = PyTuple_New(2);
3180 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3181 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3182 wxPyEndBlockThreads(blocked);
3183 return tup;
3184 }
3185 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3186 wxPyUserData* data = NULL;
3187 if ( userData ) {
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 data = new wxPyUserData(userData);
3190 wxPyEndBlockThreads(blocked);
3191 }
3192 return new wxGBSizerItem(window, pos, span, flag, border, data);
3193 }
3194 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3195 wxPyUserData* data = NULL;
3196 if ( userData ) {
3197 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3198 data = new wxPyUserData(userData);
3199 wxPyEndBlockThreads(blocked);
3200 }
3201 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3202 }
3203 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3204 wxPyUserData* data = NULL;
3205 if ( userData ) {
3206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3207 data = new wxPyUserData(userData);
3208 wxPyEndBlockThreads(blocked);
3209 }
3210 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3211 }
3212 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3213 int row, col;
3214 self->GetEndPos(row, col);
3215 return wxGBPosition(row, col);
3216 }
3217 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3218
3219 wxPyUserData* data = NULL;
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3222 if ( userData && (info.window || info.sizer || info.gotSize) )
3223 data = new wxPyUserData(userData);
3224 wxPyEndBlockThreads(blocked);
3225
3226 // Now call the real Add method if a valid item type was found
3227 if ( info.window )
3228 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3229 else if ( info.sizer )
3230 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3231 else if (info.gotSize)
3232 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3233 pos, span, flag, border, data);
3234 return NULL;
3235 }
3236
3237
3238 #ifdef __cplusplus
3239 extern "C" {
3240 #endif
3241 static int _wrap_EmptyString_set(PyObject *) {
3242 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3243 return 1;
3244 }
3245
3246
3247 static PyObject *_wrap_EmptyString_get(void) {
3248 PyObject *pyobj;
3249
3250 {
3251 #if wxUSE_UNICODE
3252 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3253 #else
3254 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3255 #endif
3256 }
3257 return pyobj;
3258 }
3259
3260
3261 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3262 PyObject *resultobj;
3263 wxObject *arg1 = (wxObject *) 0 ;
3264 wxString result;
3265 PyObject * obj0 = 0 ;
3266 char *kwnames[] = {
3267 (char *) "self", NULL
3268 };
3269
3270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3272 if (SWIG_arg_fail(1)) SWIG_fail;
3273 {
3274 PyThreadState* __tstate = wxPyBeginAllowThreads();
3275 result = wxObject_GetClassName(arg1);
3276
3277 wxPyEndAllowThreads(__tstate);
3278 if (PyErr_Occurred()) SWIG_fail;
3279 }
3280 {
3281 #if wxUSE_UNICODE
3282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3283 #else
3284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3285 #endif
3286 }
3287 return resultobj;
3288 fail:
3289 return NULL;
3290 }
3291
3292
3293 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3294 PyObject *resultobj;
3295 wxObject *arg1 = (wxObject *) 0 ;
3296 PyObject * obj0 = 0 ;
3297 char *kwnames[] = {
3298 (char *) "self", NULL
3299 };
3300
3301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3303 if (SWIG_arg_fail(1)) SWIG_fail;
3304 {
3305 PyThreadState* __tstate = wxPyBeginAllowThreads();
3306 wxObject_Destroy(arg1);
3307
3308 wxPyEndAllowThreads(__tstate);
3309 if (PyErr_Occurred()) SWIG_fail;
3310 }
3311 Py_INCREF(Py_None); resultobj = Py_None;
3312 return resultobj;
3313 fail:
3314 return NULL;
3315 }
3316
3317
3318 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3319 PyObject *obj;
3320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3321 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3322 Py_INCREF(obj);
3323 return Py_BuildValue((char *)"");
3324 }
3325 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxSize *arg1 = (wxSize *) 0 ;
3328 int arg2 ;
3329 PyObject * obj0 = 0 ;
3330 PyObject * obj1 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "self",(char *) "x", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3337 if (SWIG_arg_fail(1)) SWIG_fail;
3338 {
3339 arg2 = (int)(SWIG_As_int(obj1));
3340 if (SWIG_arg_fail(2)) SWIG_fail;
3341 }
3342 if (arg1) (arg1)->x = arg2;
3343
3344 Py_INCREF(Py_None); resultobj = Py_None;
3345 return resultobj;
3346 fail:
3347 return NULL;
3348 }
3349
3350
3351 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3352 PyObject *resultobj;
3353 wxSize *arg1 = (wxSize *) 0 ;
3354 int result;
3355 PyObject * obj0 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "self", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3362 if (SWIG_arg_fail(1)) SWIG_fail;
3363 result = (int) ((arg1)->x);
3364
3365 {
3366 resultobj = SWIG_From_int((int)(result));
3367 }
3368 return resultobj;
3369 fail:
3370 return NULL;
3371 }
3372
3373
3374 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3375 PyObject *resultobj;
3376 wxSize *arg1 = (wxSize *) 0 ;
3377 int arg2 ;
3378 PyObject * obj0 = 0 ;
3379 PyObject * obj1 = 0 ;
3380 char *kwnames[] = {
3381 (char *) "self",(char *) "y", NULL
3382 };
3383
3384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3386 if (SWIG_arg_fail(1)) SWIG_fail;
3387 {
3388 arg2 = (int)(SWIG_As_int(obj1));
3389 if (SWIG_arg_fail(2)) SWIG_fail;
3390 }
3391 if (arg1) (arg1)->y = arg2;
3392
3393 Py_INCREF(Py_None); resultobj = Py_None;
3394 return resultobj;
3395 fail:
3396 return NULL;
3397 }
3398
3399
3400 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3401 PyObject *resultobj;
3402 wxSize *arg1 = (wxSize *) 0 ;
3403 int result;
3404 PyObject * obj0 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "self", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3411 if (SWIG_arg_fail(1)) SWIG_fail;
3412 result = (int) ((arg1)->y);
3413
3414 {
3415 resultobj = SWIG_From_int((int)(result));
3416 }
3417 return resultobj;
3418 fail:
3419 return NULL;
3420 }
3421
3422
3423 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3424 PyObject *resultobj;
3425 int arg1 = (int) 0 ;
3426 int arg2 = (int) 0 ;
3427 wxSize *result;
3428 PyObject * obj0 = 0 ;
3429 PyObject * obj1 = 0 ;
3430 char *kwnames[] = {
3431 (char *) "w",(char *) "h", NULL
3432 };
3433
3434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3435 if (obj0) {
3436 {
3437 arg1 = (int)(SWIG_As_int(obj0));
3438 if (SWIG_arg_fail(1)) SWIG_fail;
3439 }
3440 }
3441 if (obj1) {
3442 {
3443 arg2 = (int)(SWIG_As_int(obj1));
3444 if (SWIG_arg_fail(2)) SWIG_fail;
3445 }
3446 }
3447 {
3448 PyThreadState* __tstate = wxPyBeginAllowThreads();
3449 result = (wxSize *)new wxSize(arg1,arg2);
3450
3451 wxPyEndAllowThreads(__tstate);
3452 if (PyErr_Occurred()) SWIG_fail;
3453 }
3454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3455 return resultobj;
3456 fail:
3457 return NULL;
3458 }
3459
3460
3461 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3462 PyObject *resultobj;
3463 wxSize *arg1 = (wxSize *) 0 ;
3464 PyObject * obj0 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "self", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3471 if (SWIG_arg_fail(1)) SWIG_fail;
3472 {
3473 PyThreadState* __tstate = wxPyBeginAllowThreads();
3474 delete arg1;
3475
3476 wxPyEndAllowThreads(__tstate);
3477 if (PyErr_Occurred()) SWIG_fail;
3478 }
3479 Py_INCREF(Py_None); resultobj = Py_None;
3480 return resultobj;
3481 fail:
3482 return NULL;
3483 }
3484
3485
3486 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3487 PyObject *resultobj;
3488 wxSize *arg1 = (wxSize *) 0 ;
3489 wxSize *arg2 = 0 ;
3490 bool result;
3491 wxSize temp2 ;
3492 PyObject * obj0 = 0 ;
3493 PyObject * obj1 = 0 ;
3494 char *kwnames[] = {
3495 (char *) "self",(char *) "sz", NULL
3496 };
3497
3498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3500 if (SWIG_arg_fail(1)) SWIG_fail;
3501 {
3502 arg2 = &temp2;
3503 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3504 }
3505 {
3506 PyThreadState* __tstate = wxPyBeginAllowThreads();
3507 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3508
3509 wxPyEndAllowThreads(__tstate);
3510 if (PyErr_Occurred()) SWIG_fail;
3511 }
3512 {
3513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3514 }
3515 return resultobj;
3516 fail:
3517 return NULL;
3518 }
3519
3520
3521 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3522 PyObject *resultobj;
3523 wxSize *arg1 = (wxSize *) 0 ;
3524 wxSize *arg2 = 0 ;
3525 bool result;
3526 wxSize temp2 ;
3527 PyObject * obj0 = 0 ;
3528 PyObject * obj1 = 0 ;
3529 char *kwnames[] = {
3530 (char *) "self",(char *) "sz", NULL
3531 };
3532
3533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3535 if (SWIG_arg_fail(1)) SWIG_fail;
3536 {
3537 arg2 = &temp2;
3538 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3539 }
3540 {
3541 PyThreadState* __tstate = wxPyBeginAllowThreads();
3542 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3543
3544 wxPyEndAllowThreads(__tstate);
3545 if (PyErr_Occurred()) SWIG_fail;
3546 }
3547 {
3548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3549 }
3550 return resultobj;
3551 fail:
3552 return NULL;
3553 }
3554
3555
3556 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 wxSize *arg1 = (wxSize *) 0 ;
3559 wxSize *arg2 = 0 ;
3560 wxSize result;
3561 wxSize temp2 ;
3562 PyObject * obj0 = 0 ;
3563 PyObject * obj1 = 0 ;
3564 char *kwnames[] = {
3565 (char *) "self",(char *) "sz", NULL
3566 };
3567
3568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3570 if (SWIG_arg_fail(1)) SWIG_fail;
3571 {
3572 arg2 = &temp2;
3573 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3574 }
3575 {
3576 PyThreadState* __tstate = wxPyBeginAllowThreads();
3577 result = (arg1)->operator +((wxSize const &)*arg2);
3578
3579 wxPyEndAllowThreads(__tstate);
3580 if (PyErr_Occurred()) SWIG_fail;
3581 }
3582 {
3583 wxSize * resultptr;
3584 resultptr = new wxSize((wxSize &)(result));
3585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3586 }
3587 return resultobj;
3588 fail:
3589 return NULL;
3590 }
3591
3592
3593 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3594 PyObject *resultobj;
3595 wxSize *arg1 = (wxSize *) 0 ;
3596 wxSize *arg2 = 0 ;
3597 wxSize result;
3598 wxSize temp2 ;
3599 PyObject * obj0 = 0 ;
3600 PyObject * obj1 = 0 ;
3601 char *kwnames[] = {
3602 (char *) "self",(char *) "sz", NULL
3603 };
3604
3605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(1)) SWIG_fail;
3608 {
3609 arg2 = &temp2;
3610 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3611 }
3612 {
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 result = (arg1)->operator -((wxSize const &)*arg2);
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 {
3620 wxSize * resultptr;
3621 resultptr = new wxSize((wxSize &)(result));
3622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3623 }
3624 return resultobj;
3625 fail:
3626 return NULL;
3627 }
3628
3629
3630 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3631 PyObject *resultobj;
3632 wxSize *arg1 = (wxSize *) 0 ;
3633 wxSize *arg2 = 0 ;
3634 wxSize temp2 ;
3635 PyObject * obj0 = 0 ;
3636 PyObject * obj1 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "self",(char *) "sz", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3643 if (SWIG_arg_fail(1)) SWIG_fail;
3644 {
3645 arg2 = &temp2;
3646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3647 }
3648 {
3649 PyThreadState* __tstate = wxPyBeginAllowThreads();
3650 (arg1)->IncTo((wxSize const &)*arg2);
3651
3652 wxPyEndAllowThreads(__tstate);
3653 if (PyErr_Occurred()) SWIG_fail;
3654 }
3655 Py_INCREF(Py_None); resultobj = Py_None;
3656 return resultobj;
3657 fail:
3658 return NULL;
3659 }
3660
3661
3662 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 wxSize *arg1 = (wxSize *) 0 ;
3665 wxSize *arg2 = 0 ;
3666 wxSize temp2 ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "self",(char *) "sz", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3675 if (SWIG_arg_fail(1)) SWIG_fail;
3676 {
3677 arg2 = &temp2;
3678 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3679 }
3680 {
3681 PyThreadState* __tstate = wxPyBeginAllowThreads();
3682 (arg1)->DecTo((wxSize const &)*arg2);
3683
3684 wxPyEndAllowThreads(__tstate);
3685 if (PyErr_Occurred()) SWIG_fail;
3686 }
3687 Py_INCREF(Py_None); resultobj = Py_None;
3688 return resultobj;
3689 fail:
3690 return NULL;
3691 }
3692
3693
3694 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3695 PyObject *resultobj;
3696 wxSize *arg1 = (wxSize *) 0 ;
3697 int arg2 ;
3698 int arg3 ;
3699 PyObject * obj0 = 0 ;
3700 PyObject * obj1 = 0 ;
3701 PyObject * obj2 = 0 ;
3702 char *kwnames[] = {
3703 (char *) "self",(char *) "w",(char *) "h", NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3708 if (SWIG_arg_fail(1)) SWIG_fail;
3709 {
3710 arg2 = (int)(SWIG_As_int(obj1));
3711 if (SWIG_arg_fail(2)) SWIG_fail;
3712 }
3713 {
3714 arg3 = (int)(SWIG_As_int(obj2));
3715 if (SWIG_arg_fail(3)) SWIG_fail;
3716 }
3717 {
3718 PyThreadState* __tstate = wxPyBeginAllowThreads();
3719 (arg1)->Set(arg2,arg3);
3720
3721 wxPyEndAllowThreads(__tstate);
3722 if (PyErr_Occurred()) SWIG_fail;
3723 }
3724 Py_INCREF(Py_None); resultobj = Py_None;
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 wxSize *arg1 = (wxSize *) 0 ;
3734 int arg2 ;
3735 PyObject * obj0 = 0 ;
3736 PyObject * obj1 = 0 ;
3737 char *kwnames[] = {
3738 (char *) "self",(char *) "w", NULL
3739 };
3740
3741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3743 if (SWIG_arg_fail(1)) SWIG_fail;
3744 {
3745 arg2 = (int)(SWIG_As_int(obj1));
3746 if (SWIG_arg_fail(2)) SWIG_fail;
3747 }
3748 {
3749 PyThreadState* __tstate = wxPyBeginAllowThreads();
3750 (arg1)->SetWidth(arg2);
3751
3752 wxPyEndAllowThreads(__tstate);
3753 if (PyErr_Occurred()) SWIG_fail;
3754 }
3755 Py_INCREF(Py_None); resultobj = Py_None;
3756 return resultobj;
3757 fail:
3758 return NULL;
3759 }
3760
3761
3762 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3763 PyObject *resultobj;
3764 wxSize *arg1 = (wxSize *) 0 ;
3765 int arg2 ;
3766 PyObject * obj0 = 0 ;
3767 PyObject * obj1 = 0 ;
3768 char *kwnames[] = {
3769 (char *) "self",(char *) "h", NULL
3770 };
3771
3772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3774 if (SWIG_arg_fail(1)) SWIG_fail;
3775 {
3776 arg2 = (int)(SWIG_As_int(obj1));
3777 if (SWIG_arg_fail(2)) SWIG_fail;
3778 }
3779 {
3780 PyThreadState* __tstate = wxPyBeginAllowThreads();
3781 (arg1)->SetHeight(arg2);
3782
3783 wxPyEndAllowThreads(__tstate);
3784 if (PyErr_Occurred()) SWIG_fail;
3785 }
3786 Py_INCREF(Py_None); resultobj = Py_None;
3787 return resultobj;
3788 fail:
3789 return NULL;
3790 }
3791
3792
3793 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3794 PyObject *resultobj;
3795 wxSize *arg1 = (wxSize *) 0 ;
3796 int result;
3797 PyObject * obj0 = 0 ;
3798 char *kwnames[] = {
3799 (char *) "self", NULL
3800 };
3801
3802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3804 if (SWIG_arg_fail(1)) SWIG_fail;
3805 {
3806 PyThreadState* __tstate = wxPyBeginAllowThreads();
3807 result = (int)((wxSize const *)arg1)->GetWidth();
3808
3809 wxPyEndAllowThreads(__tstate);
3810 if (PyErr_Occurred()) SWIG_fail;
3811 }
3812 {
3813 resultobj = SWIG_From_int((int)(result));
3814 }
3815 return resultobj;
3816 fail:
3817 return NULL;
3818 }
3819
3820
3821 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3822 PyObject *resultobj;
3823 wxSize *arg1 = (wxSize *) 0 ;
3824 int result;
3825 PyObject * obj0 = 0 ;
3826 char *kwnames[] = {
3827 (char *) "self", NULL
3828 };
3829
3830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3832 if (SWIG_arg_fail(1)) SWIG_fail;
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 result = (int)((wxSize const *)arg1)->GetHeight();
3836
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 {
3841 resultobj = SWIG_From_int((int)(result));
3842 }
3843 return resultobj;
3844 fail:
3845 return NULL;
3846 }
3847
3848
3849 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3850 PyObject *resultobj;
3851 wxSize *arg1 = (wxSize *) 0 ;
3852 bool result;
3853 PyObject * obj0 = 0 ;
3854 char *kwnames[] = {
3855 (char *) "self", NULL
3856 };
3857
3858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3860 if (SWIG_arg_fail(1)) SWIG_fail;
3861 {
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 {
3869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3870 }
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 wxSize *arg1 = (wxSize *) 0 ;
3880 wxSize *arg2 = 0 ;
3881 wxSize temp2 ;
3882 PyObject * obj0 = 0 ;
3883 PyObject * obj1 = 0 ;
3884 char *kwnames[] = {
3885 (char *) "self",(char *) "size", NULL
3886 };
3887
3888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3890 if (SWIG_arg_fail(1)) SWIG_fail;
3891 {
3892 arg2 = &temp2;
3893 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3894 }
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 (arg1)->SetDefaults((wxSize const &)*arg2);
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 Py_INCREF(Py_None); resultobj = Py_None;
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxSize *arg1 = (wxSize *) 0 ;
3912 PyObject *result;
3913 PyObject * obj0 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 result = (PyObject *)wxSize_Get(arg1);
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 resultobj = result;
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3936 PyObject *obj;
3937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3938 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3939 Py_INCREF(obj);
3940 return Py_BuildValue((char *)"");
3941 }
3942 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj;
3944 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3945 double arg2 ;
3946 PyObject * obj0 = 0 ;
3947 PyObject * obj1 = 0 ;
3948 char *kwnames[] = {
3949 (char *) "self",(char *) "x", NULL
3950 };
3951
3952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3954 if (SWIG_arg_fail(1)) SWIG_fail;
3955 {
3956 arg2 = (double)(SWIG_As_double(obj1));
3957 if (SWIG_arg_fail(2)) SWIG_fail;
3958 }
3959 if (arg1) (arg1)->x = arg2;
3960
3961 Py_INCREF(Py_None); resultobj = Py_None;
3962 return resultobj;
3963 fail:
3964 return NULL;
3965 }
3966
3967
3968 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3969 PyObject *resultobj;
3970 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3971 double result;
3972 PyObject * obj0 = 0 ;
3973 char *kwnames[] = {
3974 (char *) "self", NULL
3975 };
3976
3977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3979 if (SWIG_arg_fail(1)) SWIG_fail;
3980 result = (double) ((arg1)->x);
3981
3982 {
3983 resultobj = SWIG_From_double((double)(result));
3984 }
3985 return resultobj;
3986 fail:
3987 return NULL;
3988 }
3989
3990
3991 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3992 PyObject *resultobj;
3993 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3994 double arg2 ;
3995 PyObject * obj0 = 0 ;
3996 PyObject * obj1 = 0 ;
3997 char *kwnames[] = {
3998 (char *) "self",(char *) "y", NULL
3999 };
4000
4001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4003 if (SWIG_arg_fail(1)) SWIG_fail;
4004 {
4005 arg2 = (double)(SWIG_As_double(obj1));
4006 if (SWIG_arg_fail(2)) SWIG_fail;
4007 }
4008 if (arg1) (arg1)->y = arg2;
4009
4010 Py_INCREF(Py_None); resultobj = Py_None;
4011 return resultobj;
4012 fail:
4013 return NULL;
4014 }
4015
4016
4017 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4018 PyObject *resultobj;
4019 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4020 double result;
4021 PyObject * obj0 = 0 ;
4022 char *kwnames[] = {
4023 (char *) "self", NULL
4024 };
4025
4026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4028 if (SWIG_arg_fail(1)) SWIG_fail;
4029 result = (double) ((arg1)->y);
4030
4031 {
4032 resultobj = SWIG_From_double((double)(result));
4033 }
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4041 PyObject *resultobj;
4042 double arg1 = (double) 0.0 ;
4043 double arg2 = (double) 0.0 ;
4044 wxRealPoint *result;
4045 PyObject * obj0 = 0 ;
4046 PyObject * obj1 = 0 ;
4047 char *kwnames[] = {
4048 (char *) "x",(char *) "y", NULL
4049 };
4050
4051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4052 if (obj0) {
4053 {
4054 arg1 = (double)(SWIG_As_double(obj0));
4055 if (SWIG_arg_fail(1)) SWIG_fail;
4056 }
4057 }
4058 if (obj1) {
4059 {
4060 arg2 = (double)(SWIG_As_double(obj1));
4061 if (SWIG_arg_fail(2)) SWIG_fail;
4062 }
4063 }
4064 {
4065 PyThreadState* __tstate = wxPyBeginAllowThreads();
4066 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4067
4068 wxPyEndAllowThreads(__tstate);
4069 if (PyErr_Occurred()) SWIG_fail;
4070 }
4071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4072 return resultobj;
4073 fail:
4074 return NULL;
4075 }
4076
4077
4078 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4079 PyObject *resultobj;
4080 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4081 PyObject * obj0 = 0 ;
4082 char *kwnames[] = {
4083 (char *) "self", NULL
4084 };
4085
4086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4088 if (SWIG_arg_fail(1)) SWIG_fail;
4089 {
4090 PyThreadState* __tstate = wxPyBeginAllowThreads();
4091 delete arg1;
4092
4093 wxPyEndAllowThreads(__tstate);
4094 if (PyErr_Occurred()) SWIG_fail;
4095 }
4096 Py_INCREF(Py_None); resultobj = Py_None;
4097 return resultobj;
4098 fail:
4099 return NULL;
4100 }
4101
4102
4103 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4104 PyObject *resultobj;
4105 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4106 wxRealPoint *arg2 = 0 ;
4107 bool result;
4108 wxRealPoint temp2 ;
4109 PyObject * obj0 = 0 ;
4110 PyObject * obj1 = 0 ;
4111 char *kwnames[] = {
4112 (char *) "self",(char *) "pt", NULL
4113 };
4114
4115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 {
4119 arg2 = &temp2;
4120 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4121 }
4122 {
4123 PyThreadState* __tstate = wxPyBeginAllowThreads();
4124 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4125
4126 wxPyEndAllowThreads(__tstate);
4127 if (PyErr_Occurred()) SWIG_fail;
4128 }
4129 {
4130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4131 }
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4139 PyObject *resultobj;
4140 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4141 wxRealPoint *arg2 = 0 ;
4142 bool result;
4143 wxRealPoint temp2 ;
4144 PyObject * obj0 = 0 ;
4145 PyObject * obj1 = 0 ;
4146 char *kwnames[] = {
4147 (char *) "self",(char *) "pt", NULL
4148 };
4149
4150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4152 if (SWIG_arg_fail(1)) SWIG_fail;
4153 {
4154 arg2 = &temp2;
4155 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4156 }
4157 {
4158 PyThreadState* __tstate = wxPyBeginAllowThreads();
4159 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4160
4161 wxPyEndAllowThreads(__tstate);
4162 if (PyErr_Occurred()) SWIG_fail;
4163 }
4164 {
4165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4166 }
4167 return resultobj;
4168 fail:
4169 return NULL;
4170 }
4171
4172
4173 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4174 PyObject *resultobj;
4175 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4176 wxRealPoint *arg2 = 0 ;
4177 wxRealPoint result;
4178 wxRealPoint temp2 ;
4179 PyObject * obj0 = 0 ;
4180 PyObject * obj1 = 0 ;
4181 char *kwnames[] = {
4182 (char *) "self",(char *) "pt", NULL
4183 };
4184
4185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4187 if (SWIG_arg_fail(1)) SWIG_fail;
4188 {
4189 arg2 = &temp2;
4190 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4191 }
4192 {
4193 PyThreadState* __tstate = wxPyBeginAllowThreads();
4194 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4195
4196 wxPyEndAllowThreads(__tstate);
4197 if (PyErr_Occurred()) SWIG_fail;
4198 }
4199 {
4200 wxRealPoint * resultptr;
4201 resultptr = new wxRealPoint((wxRealPoint &)(result));
4202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4203 }
4204 return resultobj;
4205 fail:
4206 return NULL;
4207 }
4208
4209
4210 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4211 PyObject *resultobj;
4212 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4213 wxRealPoint *arg2 = 0 ;
4214 wxRealPoint result;
4215 wxRealPoint temp2 ;
4216 PyObject * obj0 = 0 ;
4217 PyObject * obj1 = 0 ;
4218 char *kwnames[] = {
4219 (char *) "self",(char *) "pt", NULL
4220 };
4221
4222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4224 if (SWIG_arg_fail(1)) SWIG_fail;
4225 {
4226 arg2 = &temp2;
4227 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4228 }
4229 {
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4232
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 wxRealPoint * resultptr;
4238 resultptr = new wxRealPoint((wxRealPoint &)(result));
4239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4240 }
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj;
4249 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4250 double arg2 ;
4251 double arg3 ;
4252 PyObject * obj0 = 0 ;
4253 PyObject * obj1 = 0 ;
4254 PyObject * obj2 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "self",(char *) "x",(char *) "y", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4261 if (SWIG_arg_fail(1)) SWIG_fail;
4262 {
4263 arg2 = (double)(SWIG_As_double(obj1));
4264 if (SWIG_arg_fail(2)) SWIG_fail;
4265 }
4266 {
4267 arg3 = (double)(SWIG_As_double(obj2));
4268 if (SWIG_arg_fail(3)) SWIG_fail;
4269 }
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 wxRealPoint_Set(arg1,arg2,arg3);
4273
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 Py_INCREF(Py_None); resultobj = Py_None;
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4285 PyObject *resultobj;
4286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4287 PyObject *result;
4288 PyObject * obj0 = 0 ;
4289 char *kwnames[] = {
4290 (char *) "self", NULL
4291 };
4292
4293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4295 if (SWIG_arg_fail(1)) SWIG_fail;
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 result = (PyObject *)wxRealPoint_Get(arg1);
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 resultobj = result;
4304 return resultobj;
4305 fail:
4306 return NULL;
4307 }
4308
4309
4310 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4311 PyObject *obj;
4312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4313 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4314 Py_INCREF(obj);
4315 return Py_BuildValue((char *)"");
4316 }
4317 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj;
4319 wxPoint *arg1 = (wxPoint *) 0 ;
4320 int arg2 ;
4321 PyObject * obj0 = 0 ;
4322 PyObject * obj1 = 0 ;
4323 char *kwnames[] = {
4324 (char *) "self",(char *) "x", NULL
4325 };
4326
4327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4329 if (SWIG_arg_fail(1)) SWIG_fail;
4330 {
4331 arg2 = (int)(SWIG_As_int(obj1));
4332 if (SWIG_arg_fail(2)) SWIG_fail;
4333 }
4334 if (arg1) (arg1)->x = arg2;
4335
4336 Py_INCREF(Py_None); resultobj = Py_None;
4337 return resultobj;
4338 fail:
4339 return NULL;
4340 }
4341
4342
4343 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4344 PyObject *resultobj;
4345 wxPoint *arg1 = (wxPoint *) 0 ;
4346 int result;
4347 PyObject * obj0 = 0 ;
4348 char *kwnames[] = {
4349 (char *) "self", NULL
4350 };
4351
4352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4354 if (SWIG_arg_fail(1)) SWIG_fail;
4355 result = (int) ((arg1)->x);
4356
4357 {
4358 resultobj = SWIG_From_int((int)(result));
4359 }
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxPoint *arg1 = (wxPoint *) 0 ;
4369 int arg2 ;
4370 PyObject * obj0 = 0 ;
4371 PyObject * obj1 = 0 ;
4372 char *kwnames[] = {
4373 (char *) "self",(char *) "y", NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4378 if (SWIG_arg_fail(1)) SWIG_fail;
4379 {
4380 arg2 = (int)(SWIG_As_int(obj1));
4381 if (SWIG_arg_fail(2)) SWIG_fail;
4382 }
4383 if (arg1) (arg1)->y = arg2;
4384
4385 Py_INCREF(Py_None); resultobj = Py_None;
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 wxPoint *arg1 = (wxPoint *) 0 ;
4395 int result;
4396 PyObject * obj0 = 0 ;
4397 char *kwnames[] = {
4398 (char *) "self", NULL
4399 };
4400
4401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4403 if (SWIG_arg_fail(1)) SWIG_fail;
4404 result = (int) ((arg1)->y);
4405
4406 {
4407 resultobj = SWIG_From_int((int)(result));
4408 }
4409 return resultobj;
4410 fail:
4411 return NULL;
4412 }
4413
4414
4415 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj;
4417 int arg1 = (int) 0 ;
4418 int arg2 = (int) 0 ;
4419 wxPoint *result;
4420 PyObject * obj0 = 0 ;
4421 PyObject * obj1 = 0 ;
4422 char *kwnames[] = {
4423 (char *) "x",(char *) "y", NULL
4424 };
4425
4426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4427 if (obj0) {
4428 {
4429 arg1 = (int)(SWIG_As_int(obj0));
4430 if (SWIG_arg_fail(1)) SWIG_fail;
4431 }
4432 }
4433 if (obj1) {
4434 {
4435 arg2 = (int)(SWIG_As_int(obj1));
4436 if (SWIG_arg_fail(2)) SWIG_fail;
4437 }
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = (wxPoint *)new wxPoint(arg1,arg2);
4442
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4454 PyObject *resultobj;
4455 wxPoint *arg1 = (wxPoint *) 0 ;
4456 PyObject * obj0 = 0 ;
4457 char *kwnames[] = {
4458 (char *) "self", NULL
4459 };
4460
4461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4463 if (SWIG_arg_fail(1)) SWIG_fail;
4464 {
4465 PyThreadState* __tstate = wxPyBeginAllowThreads();
4466 delete arg1;
4467
4468 wxPyEndAllowThreads(__tstate);
4469 if (PyErr_Occurred()) SWIG_fail;
4470 }
4471 Py_INCREF(Py_None); resultobj = Py_None;
4472 return resultobj;
4473 fail:
4474 return NULL;
4475 }
4476
4477
4478 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4479 PyObject *resultobj;
4480 wxPoint *arg1 = (wxPoint *) 0 ;
4481 wxPoint *arg2 = 0 ;
4482 bool result;
4483 wxPoint temp2 ;
4484 PyObject * obj0 = 0 ;
4485 PyObject * obj1 = 0 ;
4486 char *kwnames[] = {
4487 (char *) "self",(char *) "pt", NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4492 if (SWIG_arg_fail(1)) SWIG_fail;
4493 {
4494 arg2 = &temp2;
4495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4496 }
4497 {
4498 PyThreadState* __tstate = wxPyBeginAllowThreads();
4499 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4500
4501 wxPyEndAllowThreads(__tstate);
4502 if (PyErr_Occurred()) SWIG_fail;
4503 }
4504 {
4505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4506 }
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj;
4515 wxPoint *arg1 = (wxPoint *) 0 ;
4516 wxPoint *arg2 = 0 ;
4517 bool result;
4518 wxPoint temp2 ;
4519 PyObject * obj0 = 0 ;
4520 PyObject * obj1 = 0 ;
4521 char *kwnames[] = {
4522 (char *) "self",(char *) "pt", NULL
4523 };
4524
4525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4527 if (SWIG_arg_fail(1)) SWIG_fail;
4528 {
4529 arg2 = &temp2;
4530 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4531 }
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4535
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 {
4540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4541 }
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxPoint *arg1 = (wxPoint *) 0 ;
4551 wxPoint *arg2 = 0 ;
4552 wxPoint result;
4553 wxPoint temp2 ;
4554 PyObject * obj0 = 0 ;
4555 PyObject * obj1 = 0 ;
4556 char *kwnames[] = {
4557 (char *) "self",(char *) "pt", NULL
4558 };
4559
4560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4562 if (SWIG_arg_fail(1)) SWIG_fail;
4563 {
4564 arg2 = &temp2;
4565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4566 }
4567 {
4568 PyThreadState* __tstate = wxPyBeginAllowThreads();
4569 result = (arg1)->operator +((wxPoint const &)*arg2);
4570
4571 wxPyEndAllowThreads(__tstate);
4572 if (PyErr_Occurred()) SWIG_fail;
4573 }
4574 {
4575 wxPoint * resultptr;
4576 resultptr = new wxPoint((wxPoint &)(result));
4577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4578 }
4579 return resultobj;
4580 fail:
4581 return NULL;
4582 }
4583
4584
4585 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj;
4587 wxPoint *arg1 = (wxPoint *) 0 ;
4588 wxPoint *arg2 = 0 ;
4589 wxPoint result;
4590 wxPoint temp2 ;
4591 PyObject * obj0 = 0 ;
4592 PyObject * obj1 = 0 ;
4593 char *kwnames[] = {
4594 (char *) "self",(char *) "pt", NULL
4595 };
4596
4597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4599 if (SWIG_arg_fail(1)) SWIG_fail;
4600 {
4601 arg2 = &temp2;
4602 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4603 }
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 result = (arg1)->operator -((wxPoint const &)*arg2);
4607
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 {
4612 wxPoint * resultptr;
4613 resultptr = new wxPoint((wxPoint &)(result));
4614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4615 }
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxPoint *arg1 = (wxPoint *) 0 ;
4625 wxPoint *arg2 = 0 ;
4626 wxPoint *result;
4627 wxPoint temp2 ;
4628 PyObject * obj0 = 0 ;
4629 PyObject * obj1 = 0 ;
4630 char *kwnames[] = {
4631 (char *) "self",(char *) "pt", NULL
4632 };
4633
4634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4636 if (SWIG_arg_fail(1)) SWIG_fail;
4637 {
4638 arg2 = &temp2;
4639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4640 }
4641 {
4642 PyThreadState* __tstate = wxPyBeginAllowThreads();
4643 {
4644 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4645 result = (wxPoint *) &_result_ref;
4646 }
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxPoint *arg1 = (wxPoint *) 0 ;
4661 wxPoint *arg2 = 0 ;
4662 wxPoint *result;
4663 wxPoint temp2 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char *kwnames[] = {
4667 (char *) "self",(char *) "pt", NULL
4668 };
4669
4670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4672 if (SWIG_arg_fail(1)) SWIG_fail;
4673 {
4674 arg2 = &temp2;
4675 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4676 }
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 {
4680 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4681 result = (wxPoint *) &_result_ref;
4682 }
4683
4684 wxPyEndAllowThreads(__tstate);
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj;
4696 wxPoint *arg1 = (wxPoint *) 0 ;
4697 long arg2 ;
4698 long arg3 ;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4701 PyObject * obj2 = 0 ;
4702 char *kwnames[] = {
4703 (char *) "self",(char *) "x",(char *) "y", NULL
4704 };
4705
4706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4708 if (SWIG_arg_fail(1)) SWIG_fail;
4709 {
4710 arg2 = (long)(SWIG_As_long(obj1));
4711 if (SWIG_arg_fail(2)) SWIG_fail;
4712 }
4713 {
4714 arg3 = (long)(SWIG_As_long(obj2));
4715 if (SWIG_arg_fail(3)) SWIG_fail;
4716 }
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 wxPoint_Set(arg1,arg2,arg3);
4720
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 Py_INCREF(Py_None); resultobj = Py_None;
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4732 PyObject *resultobj;
4733 wxPoint *arg1 = (wxPoint *) 0 ;
4734 PyObject *result;
4735 PyObject * obj0 = 0 ;
4736 char *kwnames[] = {
4737 (char *) "self", NULL
4738 };
4739
4740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4742 if (SWIG_arg_fail(1)) SWIG_fail;
4743 {
4744 PyThreadState* __tstate = wxPyBeginAllowThreads();
4745 result = (PyObject *)wxPoint_Get(arg1);
4746
4747 wxPyEndAllowThreads(__tstate);
4748 if (PyErr_Occurred()) SWIG_fail;
4749 }
4750 resultobj = result;
4751 return resultobj;
4752 fail:
4753 return NULL;
4754 }
4755
4756
4757 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4758 PyObject *obj;
4759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4760 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4761 Py_INCREF(obj);
4762 return Py_BuildValue((char *)"");
4763 }
4764 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj;
4766 int arg1 = (int) 0 ;
4767 int arg2 = (int) 0 ;
4768 int arg3 = (int) 0 ;
4769 int arg4 = (int) 0 ;
4770 wxRect *result;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 PyObject * obj2 = 0 ;
4774 PyObject * obj3 = 0 ;
4775 char *kwnames[] = {
4776 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4777 };
4778
4779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4780 if (obj0) {
4781 {
4782 arg1 = (int)(SWIG_As_int(obj0));
4783 if (SWIG_arg_fail(1)) SWIG_fail;
4784 }
4785 }
4786 if (obj1) {
4787 {
4788 arg2 = (int)(SWIG_As_int(obj1));
4789 if (SWIG_arg_fail(2)) SWIG_fail;
4790 }
4791 }
4792 if (obj2) {
4793 {
4794 arg3 = (int)(SWIG_As_int(obj2));
4795 if (SWIG_arg_fail(3)) SWIG_fail;
4796 }
4797 }
4798 if (obj3) {
4799 {
4800 arg4 = (int)(SWIG_As_int(obj3));
4801 if (SWIG_arg_fail(4)) SWIG_fail;
4802 }
4803 }
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj;
4820 wxPoint *arg1 = 0 ;
4821 wxPoint *arg2 = 0 ;
4822 wxRect *result;
4823 wxPoint temp1 ;
4824 wxPoint temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "topLeft",(char *) "bottomRight", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4832 {
4833 arg1 = &temp1;
4834 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4835 }
4836 {
4837 arg2 = &temp2;
4838 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4839 }
4840 {
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj;
4856 wxPoint *arg1 = 0 ;
4857 wxSize *arg2 = 0 ;
4858 wxRect *result;
4859 wxPoint temp1 ;
4860 wxSize temp2 ;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 char *kwnames[] = {
4864 (char *) "pos",(char *) "size", NULL
4865 };
4866
4867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4868 {
4869 arg1 = &temp1;
4870 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4871 }
4872 {
4873 arg2 = &temp2;
4874 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4879
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4891 PyObject *resultobj;
4892 wxSize *arg1 = 0 ;
4893 wxRect *result;
4894 wxSize temp1 ;
4895 PyObject * obj0 = 0 ;
4896 char *kwnames[] = {
4897 (char *) "size", NULL
4898 };
4899
4900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4901 {
4902 arg1 = &temp1;
4903 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4904 }
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4908
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj;
4921 wxRect *arg1 = (wxRect *) 0 ;
4922 PyObject * obj0 = 0 ;
4923 char *kwnames[] = {
4924 (char *) "self", NULL
4925 };
4926
4927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4929 if (SWIG_arg_fail(1)) SWIG_fail;
4930 {
4931 PyThreadState* __tstate = wxPyBeginAllowThreads();
4932 delete arg1;
4933
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 Py_INCREF(Py_None); resultobj = Py_None;
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj;
4946 wxRect *arg1 = (wxRect *) 0 ;
4947 int result;
4948 PyObject * obj0 = 0 ;
4949 char *kwnames[] = {
4950 (char *) "self", NULL
4951 };
4952
4953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4955 if (SWIG_arg_fail(1)) SWIG_fail;
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 result = (int)((wxRect const *)arg1)->GetX();
4959
4960 wxPyEndAllowThreads(__tstate);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 {
4964 resultobj = SWIG_From_int((int)(result));
4965 }
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4973 PyObject *resultobj;
4974 wxRect *arg1 = (wxRect *) 0 ;
4975 int arg2 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 char *kwnames[] = {
4979 (char *) "self",(char *) "x", NULL
4980 };
4981
4982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4984 if (SWIG_arg_fail(1)) SWIG_fail;
4985 {
4986 arg2 = (int)(SWIG_As_int(obj1));
4987 if (SWIG_arg_fail(2)) SWIG_fail;
4988 }
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetX(arg2);
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 Py_INCREF(Py_None); resultobj = Py_None;
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj;
5005 wxRect *arg1 = (wxRect *) 0 ;
5006 int result;
5007 PyObject * obj0 = 0 ;
5008 char *kwnames[] = {
5009 (char *) "self", NULL
5010 };
5011
5012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5014 if (SWIG_arg_fail(1)) SWIG_fail;
5015 {
5016 PyThreadState* __tstate = wxPyBeginAllowThreads();
5017 result = (int)(arg1)->GetY();
5018
5019 wxPyEndAllowThreads(__tstate);
5020 if (PyErr_Occurred()) SWIG_fail;
5021 }
5022 {
5023 resultobj = SWIG_From_int((int)(result));
5024 }
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5032 PyObject *resultobj;
5033 wxRect *arg1 = (wxRect *) 0 ;
5034 int arg2 ;
5035 PyObject * obj0 = 0 ;
5036 PyObject * obj1 = 0 ;
5037 char *kwnames[] = {
5038 (char *) "self",(char *) "y", NULL
5039 };
5040
5041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5043 if (SWIG_arg_fail(1)) SWIG_fail;
5044 {
5045 arg2 = (int)(SWIG_As_int(obj1));
5046 if (SWIG_arg_fail(2)) SWIG_fail;
5047 }
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 (arg1)->SetY(arg2);
5051
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 Py_INCREF(Py_None); resultobj = Py_None;
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5063 PyObject *resultobj;
5064 wxRect *arg1 = (wxRect *) 0 ;
5065 int result;
5066 PyObject * obj0 = 0 ;
5067 char *kwnames[] = {
5068 (char *) "self", NULL
5069 };
5070
5071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5073 if (SWIG_arg_fail(1)) SWIG_fail;
5074 {
5075 PyThreadState* __tstate = wxPyBeginAllowThreads();
5076 result = (int)((wxRect const *)arg1)->GetWidth();
5077
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 {
5082 resultobj = SWIG_From_int((int)(result));
5083 }
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5091 PyObject *resultobj;
5092 wxRect *arg1 = (wxRect *) 0 ;
5093 int arg2 ;
5094 PyObject * obj0 = 0 ;
5095 PyObject * obj1 = 0 ;
5096 char *kwnames[] = {
5097 (char *) "self",(char *) "w", NULL
5098 };
5099
5100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5102 if (SWIG_arg_fail(1)) SWIG_fail;
5103 {
5104 arg2 = (int)(SWIG_As_int(obj1));
5105 if (SWIG_arg_fail(2)) SWIG_fail;
5106 }
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 (arg1)->SetWidth(arg2);
5110
5111 wxPyEndAllowThreads(__tstate);
5112 if (PyErr_Occurred()) SWIG_fail;
5113 }
5114 Py_INCREF(Py_None); resultobj = Py_None;
5115 return resultobj;
5116 fail:
5117 return NULL;
5118 }
5119
5120
5121 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5122 PyObject *resultobj;
5123 wxRect *arg1 = (wxRect *) 0 ;
5124 int result;
5125 PyObject * obj0 = 0 ;
5126 char *kwnames[] = {
5127 (char *) "self", NULL
5128 };
5129
5130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5132 if (SWIG_arg_fail(1)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (int)((wxRect const *)arg1)->GetHeight();
5136
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 {
5141 resultobj = SWIG_From_int((int)(result));
5142 }
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5150 PyObject *resultobj;
5151 wxRect *arg1 = (wxRect *) 0 ;
5152 int arg2 ;
5153 PyObject * obj0 = 0 ;
5154 PyObject * obj1 = 0 ;
5155 char *kwnames[] = {
5156 (char *) "self",(char *) "h", NULL
5157 };
5158
5159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5161 if (SWIG_arg_fail(1)) SWIG_fail;
5162 {
5163 arg2 = (int)(SWIG_As_int(obj1));
5164 if (SWIG_arg_fail(2)) SWIG_fail;
5165 }
5166 {
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 (arg1)->SetHeight(arg2);
5169
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 Py_INCREF(Py_None); resultobj = Py_None;
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj;
5182 wxRect *arg1 = (wxRect *) 0 ;
5183 wxPoint result;
5184 PyObject * obj0 = 0 ;
5185 char *kwnames[] = {
5186 (char *) "self", NULL
5187 };
5188
5189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5191 if (SWIG_arg_fail(1)) SWIG_fail;
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 result = ((wxRect const *)arg1)->GetPosition();
5195
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 {
5200 wxPoint * resultptr;
5201 resultptr = new wxPoint((wxPoint &)(result));
5202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5203 }
5204 return resultobj;
5205 fail:
5206 return NULL;
5207 }
5208
5209
5210 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5211 PyObject *resultobj;
5212 wxRect *arg1 = (wxRect *) 0 ;
5213 wxPoint *arg2 = 0 ;
5214 wxPoint temp2 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char *kwnames[] = {
5218 (char *) "self",(char *) "p", NULL
5219 };
5220
5221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5223 if (SWIG_arg_fail(1)) SWIG_fail;
5224 {
5225 arg2 = &temp2;
5226 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5227 }
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 (arg1)->SetPosition((wxPoint const &)*arg2);
5231
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 Py_INCREF(Py_None); resultobj = Py_None;
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj;
5244 wxRect *arg1 = (wxRect *) 0 ;
5245 wxSize result;
5246 PyObject * obj0 = 0 ;
5247 char *kwnames[] = {
5248 (char *) "self", NULL
5249 };
5250
5251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5253 if (SWIG_arg_fail(1)) SWIG_fail;
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 result = ((wxRect const *)arg1)->GetSize();
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 {
5262 wxSize * resultptr;
5263 resultptr = new wxSize((wxSize &)(result));
5264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5265 }
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj;
5274 wxRect *arg1 = (wxRect *) 0 ;
5275 wxSize *arg2 = 0 ;
5276 wxSize temp2 ;
5277 PyObject * obj0 = 0 ;
5278 PyObject * obj1 = 0 ;
5279 char *kwnames[] = {
5280 (char *) "self",(char *) "s", NULL
5281 };
5282
5283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5285 if (SWIG_arg_fail(1)) SWIG_fail;
5286 {
5287 arg2 = &temp2;
5288 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5289 }
5290 {
5291 PyThreadState* __tstate = wxPyBeginAllowThreads();
5292 (arg1)->SetSize((wxSize const &)*arg2);
5293
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 Py_INCREF(Py_None); resultobj = Py_None;
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj;
5306 wxRect *arg1 = (wxRect *) 0 ;
5307 bool result;
5308 PyObject * obj0 = 0 ;
5309 char *kwnames[] = {
5310 (char *) "self", NULL
5311 };
5312
5313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5315 if (SWIG_arg_fail(1)) SWIG_fail;
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = (bool)((wxRect const *)arg1)->IsEmpty();
5319
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj;
5334 wxRect *arg1 = (wxRect *) 0 ;
5335 wxPoint result;
5336 PyObject * obj0 = 0 ;
5337 char *kwnames[] = {
5338 (char *) "self", NULL
5339 };
5340
5341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5343 if (SWIG_arg_fail(1)) SWIG_fail;
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = ((wxRect const *)arg1)->GetTopLeft();
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 wxPoint * resultptr;
5353 resultptr = new wxPoint((wxPoint &)(result));
5354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5355 }
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxRect *arg1 = (wxRect *) 0 ;
5365 wxPoint *arg2 = 0 ;
5366 wxPoint temp2 ;
5367 PyObject * obj0 = 0 ;
5368 PyObject * obj1 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self",(char *) "p", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 {
5377 arg2 = &temp2;
5378 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5379 }
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5383
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 Py_INCREF(Py_None); resultobj = Py_None;
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxRect *arg1 = (wxRect *) 0 ;
5397 wxPoint result;
5398 PyObject * obj0 = 0 ;
5399 char *kwnames[] = {
5400 (char *) "self", NULL
5401 };
5402
5403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(1)) SWIG_fail;
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = ((wxRect const *)arg1)->GetBottomRight();
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 wxPoint * resultptr;
5415 resultptr = new wxPoint((wxPoint &)(result));
5416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj;
5426 wxRect *arg1 = (wxRect *) 0 ;
5427 wxPoint *arg2 = 0 ;
5428 wxPoint temp2 ;
5429 PyObject * obj0 = 0 ;
5430 PyObject * obj1 = 0 ;
5431 char *kwnames[] = {
5432 (char *) "self",(char *) "p", NULL
5433 };
5434
5435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5437 if (SWIG_arg_fail(1)) SWIG_fail;
5438 {
5439 arg2 = &temp2;
5440 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5441 }
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 Py_INCREF(Py_None); resultobj = Py_None;
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5457 PyObject *resultobj;
5458 wxRect *arg1 = (wxRect *) 0 ;
5459 int result;
5460 PyObject * obj0 = 0 ;
5461 char *kwnames[] = {
5462 (char *) "self", NULL
5463 };
5464
5465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5467 if (SWIG_arg_fail(1)) SWIG_fail;
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (int)((wxRect const *)arg1)->GetLeft();
5471
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 resultobj = SWIG_From_int((int)(result));
5477 }
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5485 PyObject *resultobj;
5486 wxRect *arg1 = (wxRect *) 0 ;
5487 int result;
5488 PyObject * obj0 = 0 ;
5489 char *kwnames[] = {
5490 (char *) "self", NULL
5491 };
5492
5493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5495 if (SWIG_arg_fail(1)) SWIG_fail;
5496 {
5497 PyThreadState* __tstate = wxPyBeginAllowThreads();
5498 result = (int)((wxRect const *)arg1)->GetTop();
5499
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 {
5504 resultobj = SWIG_From_int((int)(result));
5505 }
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5513 PyObject *resultobj;
5514 wxRect *arg1 = (wxRect *) 0 ;
5515 int result;
5516 PyObject * obj0 = 0 ;
5517 char *kwnames[] = {
5518 (char *) "self", NULL
5519 };
5520
5521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5523 if (SWIG_arg_fail(1)) SWIG_fail;
5524 {
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 result = (int)((wxRect const *)arg1)->GetBottom();
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = SWIG_From_int((int)(result));
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 wxRect *arg1 = (wxRect *) 0 ;
5543 int result;
5544 PyObject * obj0 = 0 ;
5545 char *kwnames[] = {
5546 (char *) "self", NULL
5547 };
5548
5549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5551 if (SWIG_arg_fail(1)) SWIG_fail;
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 result = (int)((wxRect const *)arg1)->GetRight();
5555
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 {
5560 resultobj = SWIG_From_int((int)(result));
5561 }
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj;
5570 wxRect *arg1 = (wxRect *) 0 ;
5571 int arg2 ;
5572 PyObject * obj0 = 0 ;
5573 PyObject * obj1 = 0 ;
5574 char *kwnames[] = {
5575 (char *) "self",(char *) "left", NULL
5576 };
5577
5578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5580 if (SWIG_arg_fail(1)) SWIG_fail;
5581 {
5582 arg2 = (int)(SWIG_As_int(obj1));
5583 if (SWIG_arg_fail(2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 (arg1)->SetLeft(arg2);
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 Py_INCREF(Py_None); resultobj = Py_None;
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 wxRect *arg1 = (wxRect *) 0 ;
5602 int arg2 ;
5603 PyObject * obj0 = 0 ;
5604 PyObject * obj1 = 0 ;
5605 char *kwnames[] = {
5606 (char *) "self",(char *) "right", NULL
5607 };
5608
5609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5611 if (SWIG_arg_fail(1)) SWIG_fail;
5612 {
5613 arg2 = (int)(SWIG_As_int(obj1));
5614 if (SWIG_arg_fail(2)) SWIG_fail;
5615 }
5616 {
5617 PyThreadState* __tstate = wxPyBeginAllowThreads();
5618 (arg1)->SetRight(arg2);
5619
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 Py_INCREF(Py_None); resultobj = Py_None;
5624 return resultobj;
5625 fail:
5626 return NULL;
5627 }
5628
5629
5630 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5631 PyObject *resultobj;
5632 wxRect *arg1 = (wxRect *) 0 ;
5633 int arg2 ;
5634 PyObject * obj0 = 0 ;
5635 PyObject * obj1 = 0 ;
5636 char *kwnames[] = {
5637 (char *) "self",(char *) "top", NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5642 if (SWIG_arg_fail(1)) SWIG_fail;
5643 {
5644 arg2 = (int)(SWIG_As_int(obj1));
5645 if (SWIG_arg_fail(2)) SWIG_fail;
5646 }
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 (arg1)->SetTop(arg2);
5650
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 Py_INCREF(Py_None); resultobj = Py_None;
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj;
5663 wxRect *arg1 = (wxRect *) 0 ;
5664 int arg2 ;
5665 PyObject * obj0 = 0 ;
5666 PyObject * obj1 = 0 ;
5667 char *kwnames[] = {
5668 (char *) "self",(char *) "bottom", NULL
5669 };
5670
5671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5673 if (SWIG_arg_fail(1)) SWIG_fail;
5674 {
5675 arg2 = (int)(SWIG_As_int(obj1));
5676 if (SWIG_arg_fail(2)) SWIG_fail;
5677 }
5678 {
5679 PyThreadState* __tstate = wxPyBeginAllowThreads();
5680 (arg1)->SetBottom(arg2);
5681
5682 wxPyEndAllowThreads(__tstate);
5683 if (PyErr_Occurred()) SWIG_fail;
5684 }
5685 Py_INCREF(Py_None); resultobj = Py_None;
5686 return resultobj;
5687 fail:
5688 return NULL;
5689 }
5690
5691
5692 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5693 PyObject *resultobj;
5694 wxRect *arg1 = (wxRect *) 0 ;
5695 int arg2 ;
5696 int arg3 ;
5697 wxRect *result;
5698 PyObject * obj0 = 0 ;
5699 PyObject * obj1 = 0 ;
5700 PyObject * obj2 = 0 ;
5701 char *kwnames[] = {
5702 (char *) "self",(char *) "dx",(char *) "dy", NULL
5703 };
5704
5705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5707 if (SWIG_arg_fail(1)) SWIG_fail;
5708 {
5709 arg2 = (int)(SWIG_As_int(obj1));
5710 if (SWIG_arg_fail(2)) SWIG_fail;
5711 }
5712 {
5713 arg3 = (int)(SWIG_As_int(obj2));
5714 if (SWIG_arg_fail(3)) SWIG_fail;
5715 }
5716 {
5717 PyThreadState* __tstate = wxPyBeginAllowThreads();
5718 {
5719 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5720 result = (wxRect *) &_result_ref;
5721 }
5722
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj;
5735 wxRect *arg1 = (wxRect *) 0 ;
5736 int arg2 ;
5737 int arg3 ;
5738 wxRect *result;
5739 PyObject * obj0 = 0 ;
5740 PyObject * obj1 = 0 ;
5741 PyObject * obj2 = 0 ;
5742 char *kwnames[] = {
5743 (char *) "self",(char *) "dx",(char *) "dy", NULL
5744 };
5745
5746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5748 if (SWIG_arg_fail(1)) SWIG_fail;
5749 {
5750 arg2 = (int)(SWIG_As_int(obj1));
5751 if (SWIG_arg_fail(2)) SWIG_fail;
5752 }
5753 {
5754 arg3 = (int)(SWIG_As_int(obj2));
5755 if (SWIG_arg_fail(3)) SWIG_fail;
5756 }
5757 {
5758 PyThreadState* __tstate = wxPyBeginAllowThreads();
5759 {
5760 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5761 result = (wxRect *) &_result_ref;
5762 }
5763
5764 wxPyEndAllowThreads(__tstate);
5765 if (PyErr_Occurred()) SWIG_fail;
5766 }
5767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5768 return resultobj;
5769 fail:
5770 return NULL;
5771 }
5772
5773
5774 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5775 PyObject *resultobj;
5776 wxRect *arg1 = (wxRect *) 0 ;
5777 int arg2 ;
5778 int arg3 ;
5779 PyObject * obj0 = 0 ;
5780 PyObject * obj1 = 0 ;
5781 PyObject * obj2 = 0 ;
5782 char *kwnames[] = {
5783 (char *) "self",(char *) "dx",(char *) "dy", NULL
5784 };
5785
5786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5788 if (SWIG_arg_fail(1)) SWIG_fail;
5789 {
5790 arg2 = (int)(SWIG_As_int(obj1));
5791 if (SWIG_arg_fail(2)) SWIG_fail;
5792 }
5793 {
5794 arg3 = (int)(SWIG_As_int(obj2));
5795 if (SWIG_arg_fail(3)) SWIG_fail;
5796 }
5797 {
5798 PyThreadState* __tstate = wxPyBeginAllowThreads();
5799 (arg1)->Offset(arg2,arg3);
5800
5801 wxPyEndAllowThreads(__tstate);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 Py_INCREF(Py_None); resultobj = Py_None;
5805 return resultobj;
5806 fail:
5807 return NULL;
5808 }
5809
5810
5811 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5812 PyObject *resultobj;
5813 wxRect *arg1 = (wxRect *) 0 ;
5814 wxPoint *arg2 = 0 ;
5815 wxPoint temp2 ;
5816 PyObject * obj0 = 0 ;
5817 PyObject * obj1 = 0 ;
5818 char *kwnames[] = {
5819 (char *) "self",(char *) "pt", NULL
5820 };
5821
5822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5824 if (SWIG_arg_fail(1)) SWIG_fail;
5825 {
5826 arg2 = &temp2;
5827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5828 }
5829 {
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 (arg1)->Offset((wxPoint const &)*arg2);
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 Py_INCREF(Py_None); resultobj = Py_None;
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj;
5845 wxRect *arg1 = (wxRect *) 0 ;
5846 wxRect *arg2 = 0 ;
5847 wxRect result;
5848 wxRect temp2 ;
5849 PyObject * obj0 = 0 ;
5850 PyObject * obj1 = 0 ;
5851 char *kwnames[] = {
5852 (char *) "self",(char *) "rect", NULL
5853 };
5854
5855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5857 if (SWIG_arg_fail(1)) SWIG_fail;
5858 {
5859 arg2 = &temp2;
5860 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5861 }
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 result = (arg1)->Intersect((wxRect const &)*arg2);
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 {
5870 wxRect * resultptr;
5871 resultptr = new wxRect((wxRect &)(result));
5872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5873 }
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5881 PyObject *resultobj;
5882 wxRect *arg1 = (wxRect *) 0 ;
5883 wxRect *arg2 = 0 ;
5884 wxRect result;
5885 wxRect temp2 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 char *kwnames[] = {
5889 (char *) "self",(char *) "rect", NULL
5890 };
5891
5892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5894 if (SWIG_arg_fail(1)) SWIG_fail;
5895 {
5896 arg2 = &temp2;
5897 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5898 }
5899 {
5900 PyThreadState* __tstate = wxPyBeginAllowThreads();
5901 result = (arg1)->Union((wxRect const &)*arg2);
5902
5903 wxPyEndAllowThreads(__tstate);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 {
5907 wxRect * resultptr;
5908 resultptr = new wxRect((wxRect &)(result));
5909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5910 }
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 wxRect *arg1 = (wxRect *) 0 ;
5920 wxRect *arg2 = 0 ;
5921 wxRect result;
5922 wxRect temp2 ;
5923 PyObject * obj0 = 0 ;
5924 PyObject * obj1 = 0 ;
5925 char *kwnames[] = {
5926 (char *) "self",(char *) "rect", NULL
5927 };
5928
5929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5931 if (SWIG_arg_fail(1)) SWIG_fail;
5932 {
5933 arg2 = &temp2;
5934 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5935 }
5936 {
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5939
5940 wxPyEndAllowThreads(__tstate);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 {
5944 wxRect * resultptr;
5945 resultptr = new wxRect((wxRect &)(result));
5946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5947 }
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5955 PyObject *resultobj;
5956 wxRect *arg1 = (wxRect *) 0 ;
5957 wxRect *arg2 = 0 ;
5958 wxRect *result;
5959 wxRect temp2 ;
5960 PyObject * obj0 = 0 ;
5961 PyObject * obj1 = 0 ;
5962 char *kwnames[] = {
5963 (char *) "self",(char *) "rect", NULL
5964 };
5965
5966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5968 if (SWIG_arg_fail(1)) SWIG_fail;
5969 {
5970 arg2 = &temp2;
5971 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5972 }
5973 {
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 {
5976 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5977 result = (wxRect *) &_result_ref;
5978 }
5979
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5984 return resultobj;
5985 fail:
5986 return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5991 PyObject *resultobj;
5992 wxRect *arg1 = (wxRect *) 0 ;
5993 wxRect *arg2 = 0 ;
5994 bool result;
5995 wxRect temp2 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 char *kwnames[] = {
5999 (char *) "self",(char *) "rect", NULL
6000 };
6001
6002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6004 if (SWIG_arg_fail(1)) SWIG_fail;
6005 {
6006 arg2 = &temp2;
6007 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6008 }
6009 {
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 {
6017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6018 }
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 wxRect *arg1 = (wxRect *) 0 ;
6028 wxRect *arg2 = 0 ;
6029 bool result;
6030 wxRect temp2 ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 char *kwnames[] = {
6034 (char *) "self",(char *) "rect", NULL
6035 };
6036
6037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6039 if (SWIG_arg_fail(1)) SWIG_fail;
6040 {
6041 arg2 = &temp2;
6042 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6043 }
6044 {
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6047
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6053 }
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj;
6062 wxRect *arg1 = (wxRect *) 0 ;
6063 int arg2 ;
6064 int arg3 ;
6065 bool result;
6066 PyObject * obj0 = 0 ;
6067 PyObject * obj1 = 0 ;
6068 PyObject * obj2 = 0 ;
6069 char *kwnames[] = {
6070 (char *) "self",(char *) "x",(char *) "y", NULL
6071 };
6072
6073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6075 if (SWIG_arg_fail(1)) SWIG_fail;
6076 {
6077 arg2 = (int)(SWIG_As_int(obj1));
6078 if (SWIG_arg_fail(2)) SWIG_fail;
6079 }
6080 {
6081 arg3 = (int)(SWIG_As_int(obj2));
6082 if (SWIG_arg_fail(3)) SWIG_fail;
6083 }
6084 {
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 {
6092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6093 }
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj;
6102 wxRect *arg1 = (wxRect *) 0 ;
6103 wxPoint *arg2 = 0 ;
6104 bool result;
6105 wxPoint temp2 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 char *kwnames[] = {
6109 (char *) "self",(char *) "pt", NULL
6110 };
6111
6112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6114 if (SWIG_arg_fail(1)) SWIG_fail;
6115 {
6116 arg2 = &temp2;
6117 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6122
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 {
6127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6128 }
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 wxRect *arg2 = 0 ;
6139 bool result;
6140 wxRect temp2 ;
6141 PyObject * obj0 = 0 ;
6142 PyObject * obj1 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "self",(char *) "rect", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6149 if (SWIG_arg_fail(1)) SWIG_fail;
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6157
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 {
6162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6163 }
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 wxRect *arg1 = (wxRect *) 0 ;
6173 int arg2 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "self",(char *) "x", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 {
6184 arg2 = (int)(SWIG_As_int(obj1));
6185 if (SWIG_arg_fail(2)) SWIG_fail;
6186 }
6187 if (arg1) (arg1)->x = arg2;
6188
6189 Py_INCREF(Py_None); resultobj = Py_None;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6197 PyObject *resultobj;
6198 wxRect *arg1 = (wxRect *) 0 ;
6199 int result;
6200 PyObject * obj0 = 0 ;
6201 char *kwnames[] = {
6202 (char *) "self", NULL
6203 };
6204
6205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6207 if (SWIG_arg_fail(1)) SWIG_fail;
6208 result = (int) ((arg1)->x);
6209
6210 {
6211 resultobj = SWIG_From_int((int)(result));
6212 }
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 wxRect *arg1 = (wxRect *) 0 ;
6222 int arg2 ;
6223 PyObject * obj0 = 0 ;
6224 PyObject * obj1 = 0 ;
6225 char *kwnames[] = {
6226 (char *) "self",(char *) "y", NULL
6227 };
6228
6229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6231 if (SWIG_arg_fail(1)) SWIG_fail;
6232 {
6233 arg2 = (int)(SWIG_As_int(obj1));
6234 if (SWIG_arg_fail(2)) SWIG_fail;
6235 }
6236 if (arg1) (arg1)->y = arg2;
6237
6238 Py_INCREF(Py_None); resultobj = Py_None;
6239 return resultobj;
6240 fail:
6241 return NULL;
6242 }
6243
6244
6245 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6246 PyObject *resultobj;
6247 wxRect *arg1 = (wxRect *) 0 ;
6248 int result;
6249 PyObject * obj0 = 0 ;
6250 char *kwnames[] = {
6251 (char *) "self", NULL
6252 };
6253
6254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6256 if (SWIG_arg_fail(1)) SWIG_fail;
6257 result = (int) ((arg1)->y);
6258
6259 {
6260 resultobj = SWIG_From_int((int)(result));
6261 }
6262 return resultobj;
6263 fail:
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxRect *arg1 = (wxRect *) 0 ;
6271 int arg2 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self",(char *) "width", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 arg2 = (int)(SWIG_As_int(obj1));
6283 if (SWIG_arg_fail(2)) SWIG_fail;
6284 }
6285 if (arg1) (arg1)->width = arg2;
6286
6287 Py_INCREF(Py_None); resultobj = Py_None;
6288 return resultobj;
6289 fail:
6290 return NULL;
6291 }
6292
6293
6294 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6295 PyObject *resultobj;
6296 wxRect *arg1 = (wxRect *) 0 ;
6297 int result;
6298 PyObject * obj0 = 0 ;
6299 char *kwnames[] = {
6300 (char *) "self", NULL
6301 };
6302
6303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6305 if (SWIG_arg_fail(1)) SWIG_fail;
6306 result = (int) ((arg1)->width);
6307
6308 {
6309 resultobj = SWIG_From_int((int)(result));
6310 }
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj;
6319 wxRect *arg1 = (wxRect *) 0 ;
6320 int arg2 ;
6321 PyObject * obj0 = 0 ;
6322 PyObject * obj1 = 0 ;
6323 char *kwnames[] = {
6324 (char *) "self",(char *) "height", NULL
6325 };
6326
6327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6329 if (SWIG_arg_fail(1)) SWIG_fail;
6330 {
6331 arg2 = (int)(SWIG_As_int(obj1));
6332 if (SWIG_arg_fail(2)) SWIG_fail;
6333 }
6334 if (arg1) (arg1)->height = arg2;
6335
6336 Py_INCREF(Py_None); resultobj = Py_None;
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 PyObject * obj0 = 0 ;
6348 char *kwnames[] = {
6349 (char *) "self", NULL
6350 };
6351
6352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6354 if (SWIG_arg_fail(1)) SWIG_fail;
6355 result = (int) ((arg1)->height);
6356
6357 {
6358 resultobj = SWIG_From_int((int)(result));
6359 }
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj;
6368 wxRect *arg1 = (wxRect *) 0 ;
6369 int arg2 = (int) 0 ;
6370 int arg3 = (int) 0 ;
6371 int arg4 = (int) 0 ;
6372 int arg5 = (int) 0 ;
6373 PyObject * obj0 = 0 ;
6374 PyObject * obj1 = 0 ;
6375 PyObject * obj2 = 0 ;
6376 PyObject * obj3 = 0 ;
6377 PyObject * obj4 = 0 ;
6378 char *kwnames[] = {
6379 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6380 };
6381
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 if (obj1) {
6386 {
6387 arg2 = (int)(SWIG_As_int(obj1));
6388 if (SWIG_arg_fail(2)) SWIG_fail;
6389 }
6390 }
6391 if (obj2) {
6392 {
6393 arg3 = (int)(SWIG_As_int(obj2));
6394 if (SWIG_arg_fail(3)) SWIG_fail;
6395 }
6396 }
6397 if (obj3) {
6398 {
6399 arg4 = (int)(SWIG_As_int(obj3));
6400 if (SWIG_arg_fail(4)) SWIG_fail;
6401 }
6402 }
6403 if (obj4) {
6404 {
6405 arg5 = (int)(SWIG_As_int(obj4));
6406 if (SWIG_arg_fail(5)) SWIG_fail;
6407 }
6408 }
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 Py_INCREF(Py_None); resultobj = Py_None;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 PyObject *result;
6427 PyObject * obj0 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "self", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 {
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 result = (PyObject *)wxRect_Get(arg1);
6438
6439 wxPyEndAllowThreads(__tstate);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = result;
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6450 PyObject *obj;
6451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6452 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6453 Py_INCREF(obj);
6454 return Py_BuildValue((char *)"");
6455 }
6456 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 wxRect *arg2 = (wxRect *) 0 ;
6460 PyObject *result;
6461 PyObject * obj0 = 0 ;
6462 PyObject * obj1 = 0 ;
6463 char *kwnames[] = {
6464 (char *) "r1",(char *) "r2", NULL
6465 };
6466
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6471 if (SWIG_arg_fail(2)) SWIG_fail;
6472 {
6473 if (!wxPyCheckForApp()) SWIG_fail;
6474 PyThreadState* __tstate = wxPyBeginAllowThreads();
6475 result = (PyObject *)wxIntersectRect(arg1,arg2);
6476
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = result;
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj;
6489 double arg1 = (double) 0.0 ;
6490 double arg2 = (double) 0.0 ;
6491 wxPoint2D *result;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 char *kwnames[] = {
6495 (char *) "x",(char *) "y", NULL
6496 };
6497
6498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6499 if (obj0) {
6500 {
6501 arg1 = (double)(SWIG_As_double(obj0));
6502 if (SWIG_arg_fail(1)) SWIG_fail;
6503 }
6504 }
6505 if (obj1) {
6506 {
6507 arg2 = (double)(SWIG_As_double(obj1));
6508 if (SWIG_arg_fail(2)) SWIG_fail;
6509 }
6510 }
6511 {
6512 PyThreadState* __tstate = wxPyBeginAllowThreads();
6513 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6514
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxPoint2D *arg1 = 0 ;
6528 wxPoint2D *result;
6529 wxPoint2D temp1 ;
6530 PyObject * obj0 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "pt", NULL
6533 };
6534
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6536 {
6537 arg1 = &temp1;
6538 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6539 }
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6543
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj;
6556 wxPoint *arg1 = 0 ;
6557 wxPoint2D *result;
6558 wxPoint temp1 ;
6559 PyObject * obj0 = 0 ;
6560 char *kwnames[] = {
6561 (char *) "pt", NULL
6562 };
6563
6564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6565 {
6566 arg1 = &temp1;
6567 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6568 }
6569 {
6570 PyThreadState* __tstate = wxPyBeginAllowThreads();
6571 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6572
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6584 PyObject *resultobj;
6585 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6586 int *arg2 = (int *) 0 ;
6587 int *arg3 = (int *) 0 ;
6588 int temp2 ;
6589 int res2 = 0 ;
6590 int temp3 ;
6591 int res3 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "self", NULL
6595 };
6596
6597 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6598 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6601 if (SWIG_arg_fail(1)) SWIG_fail;
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 Py_INCREF(Py_None); resultobj = Py_None;
6610 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6611 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6612 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6613 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6623 int *arg2 = (int *) 0 ;
6624 int *arg3 = (int *) 0 ;
6625 int temp2 ;
6626 int res2 = 0 ;
6627 int temp3 ;
6628 int res3 = 0 ;
6629 PyObject * obj0 = 0 ;
6630 char *kwnames[] = {
6631 (char *) "self", NULL
6632 };
6633
6634 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6635 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6638 if (SWIG_arg_fail(1)) SWIG_fail;
6639 {
6640 PyThreadState* __tstate = wxPyBeginAllowThreads();
6641 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6642
6643 wxPyEndAllowThreads(__tstate);
6644 if (PyErr_Occurred()) SWIG_fail;
6645 }
6646 Py_INCREF(Py_None); resultobj = Py_None;
6647 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6648 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6649 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6650 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj;
6659 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6660 double result;
6661 PyObject * obj0 = 0 ;
6662 char *kwnames[] = {
6663 (char *) "self", NULL
6664 };
6665
6666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6668 if (SWIG_arg_fail(1)) SWIG_fail;
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 {
6677 resultobj = SWIG_From_double((double)(result));
6678 }
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6686 PyObject *resultobj;
6687 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6688 double result;
6689 PyObject * obj0 = 0 ;
6690 char *kwnames[] = {
6691 (char *) "self", NULL
6692 };
6693
6694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6696 if (SWIG_arg_fail(1)) SWIG_fail;
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 {
6705 resultobj = SWIG_From_double((double)(result));
6706 }
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6716 double arg2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "length", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = (double)(SWIG_As_double(obj1));
6728 if (SWIG_arg_fail(2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->SetVectorLength(arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 Py_INCREF(Py_None); resultobj = Py_None;
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj;
6746 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6747 double arg2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "degrees", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = (double)(SWIG_As_double(obj1));
6759 if (SWIG_arg_fail(2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 (arg1)->SetVectorAngle(arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 Py_INCREF(Py_None); resultobj = Py_None;
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6778 wxPoint2D *arg2 = 0 ;
6779 double result;
6780 wxPoint2D temp2 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self",(char *) "pt", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 arg2 = &temp2;
6792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6793 }
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6797
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 {
6802 resultobj = SWIG_From_double((double)(result));
6803 }
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6813 wxPoint2D *arg2 = 0 ;
6814 double result;
6815 wxPoint2D temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "pt", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6832
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 {
6837 resultobj = SWIG_From_double((double)(result));
6838 }
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6848 wxPoint2D *arg2 = 0 ;
6849 double result;
6850 wxPoint2D temp2 ;
6851 PyObject * obj0 = 0 ;
6852 PyObject * obj1 = 0 ;
6853 char *kwnames[] = {
6854 (char *) "self",(char *) "vec", NULL
6855 };
6856
6857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 {
6861 arg2 = &temp2;
6862 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 {
6872 resultobj = SWIG_From_double((double)(result));
6873 }
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6883 wxPoint2D *arg2 = 0 ;
6884 double result;
6885 wxPoint2D temp2 ;
6886 PyObject * obj0 = 0 ;
6887 PyObject * obj1 = 0 ;
6888 char *kwnames[] = {
6889 (char *) "self",(char *) "vec", NULL
6890 };
6891
6892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6894 if (SWIG_arg_fail(1)) SWIG_fail;
6895 {
6896 arg2 = &temp2;
6897 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6898 }
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6902
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 {
6907 resultobj = SWIG_From_double((double)(result));
6908 }
6909 return resultobj;
6910 fail:
6911 return NULL;
6912 }
6913
6914
6915 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6916 PyObject *resultobj;
6917 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6918 wxPoint2D result;
6919 PyObject * obj0 = 0 ;
6920 char *kwnames[] = {
6921 (char *) "self", NULL
6922 };
6923
6924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6926 if (SWIG_arg_fail(1)) SWIG_fail;
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (arg1)->operator -();
6930
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 {
6935 wxPoint2D * resultptr;
6936 resultptr = new wxPoint2D((wxPoint2D &)(result));
6937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6938 }
6939 return resultobj;
6940 fail:
6941 return NULL;
6942 }
6943
6944
6945 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6946 PyObject *resultobj;
6947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6948 wxPoint2D *arg2 = 0 ;
6949 wxPoint2D *result;
6950 wxPoint2D temp2 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "pt", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 arg2 = &temp2;
6962 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6963 }
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 {
6967 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6968 result = (wxPoint2D *) &_result_ref;
6969 }
6970
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj;
6983 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6984 wxPoint2D *arg2 = 0 ;
6985 wxPoint2D *result;
6986 wxPoint2D temp2 ;
6987 PyObject * obj0 = 0 ;
6988 PyObject * obj1 = 0 ;
6989 char *kwnames[] = {
6990 (char *) "self",(char *) "pt", NULL
6991 };
6992
6993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6995 if (SWIG_arg_fail(1)) SWIG_fail;
6996 {
6997 arg2 = &temp2;
6998 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6999 }
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 {
7003 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7004 result = (wxPoint2D *) &_result_ref;
7005 }
7006
7007 wxPyEndAllowThreads(__tstate);
7008 if (PyErr_Occurred()) SWIG_fail;
7009 }
7010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7011 return resultobj;
7012 fail:
7013 return NULL;
7014 }
7015
7016
7017 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj;
7019 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7020 wxPoint2D *arg2 = 0 ;
7021 wxPoint2D *result;
7022 wxPoint2D temp2 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char *kwnames[] = {
7026 (char *) "self",(char *) "pt", NULL
7027 };
7028
7029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7031 if (SWIG_arg_fail(1)) SWIG_fail;
7032 {
7033 arg2 = &temp2;
7034 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7035 }
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 {
7039 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7040 result = (wxPoint2D *) &_result_ref;
7041 }
7042
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj;
7055 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7056 wxPoint2D *arg2 = 0 ;
7057 wxPoint2D *result;
7058 wxPoint2D temp2 ;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 char *kwnames[] = {
7062 (char *) "self",(char *) "pt", NULL
7063 };
7064
7065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7067 if (SWIG_arg_fail(1)) SWIG_fail;
7068 {
7069 arg2 = &temp2;
7070 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7071 }
7072 {
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 {
7075 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7076 result = (wxPoint2D *) &_result_ref;
7077 }
7078
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7092 wxPoint2D *arg2 = 0 ;
7093 bool result;
7094 wxPoint2D temp2 ;
7095 PyObject * obj0 = 0 ;
7096 PyObject * obj1 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "self",(char *) "pt", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 {
7105 arg2 = &temp2;
7106 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7107 }
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj;
7126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7127 wxPoint2D *arg2 = 0 ;
7128 bool result;
7129 wxPoint2D temp2 ;
7130 PyObject * obj0 = 0 ;
7131 PyObject * obj1 = 0 ;
7132 char *kwnames[] = {
7133 (char *) "self",(char *) "pt", NULL
7134 };
7135
7136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7138 if (SWIG_arg_fail(1)) SWIG_fail;
7139 {
7140 arg2 = &temp2;
7141 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7142 }
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7146
7147 wxPyEndAllowThreads(__tstate);
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 {
7151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7152 }
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj;
7161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7162 double arg2 ;
7163 PyObject * obj0 = 0 ;
7164 PyObject * obj1 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self",(char *) "m_x", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 arg2 = (double)(SWIG_As_double(obj1));
7174 if (SWIG_arg_fail(2)) SWIG_fail;
7175 }
7176 if (arg1) (arg1)->m_x = arg2;
7177
7178 Py_INCREF(Py_None); resultobj = Py_None;
7179 return resultobj;
7180 fail:
7181 return NULL;
7182 }
7183
7184
7185 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7186 PyObject *resultobj;
7187 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7188 double result;
7189 PyObject * obj0 = 0 ;
7190 char *kwnames[] = {
7191 (char *) "self", NULL
7192 };
7193
7194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7196 if (SWIG_arg_fail(1)) SWIG_fail;
7197 result = (double) ((arg1)->m_x);
7198
7199 {
7200 resultobj = SWIG_From_double((double)(result));
7201 }
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj;
7210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7211 double arg2 ;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "self",(char *) "m_y", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 {
7222 arg2 = (double)(SWIG_As_double(obj1));
7223 if (SWIG_arg_fail(2)) SWIG_fail;
7224 }
7225 if (arg1) (arg1)->m_y = arg2;
7226
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7237 double result;
7238 PyObject * obj0 = 0 ;
7239 char *kwnames[] = {
7240 (char *) "self", NULL
7241 };
7242
7243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7245 if (SWIG_arg_fail(1)) SWIG_fail;
7246 result = (double) ((arg1)->m_y);
7247
7248 {
7249 resultobj = SWIG_From_double((double)(result));
7250 }
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj;
7259 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7260 double arg2 = (double) 0 ;
7261 double arg3 = (double) 0 ;
7262 PyObject * obj0 = 0 ;
7263 PyObject * obj1 = 0 ;
7264 PyObject * obj2 = 0 ;
7265 char *kwnames[] = {
7266 (char *) "self",(char *) "x",(char *) "y", NULL
7267 };
7268
7269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7271 if (SWIG_arg_fail(1)) SWIG_fail;
7272 if (obj1) {
7273 {
7274 arg2 = (double)(SWIG_As_double(obj1));
7275 if (SWIG_arg_fail(2)) SWIG_fail;
7276 }
7277 }
7278 if (obj2) {
7279 {
7280 arg3 = (double)(SWIG_As_double(obj2));
7281 if (SWIG_arg_fail(3)) SWIG_fail;
7282 }
7283 }
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 wxPoint2D_Set(arg1,arg2,arg3);
7287
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 Py_INCREF(Py_None); resultobj = Py_None;
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj;
7300 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7301 PyObject *result;
7302 PyObject * obj0 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (PyObject *)wxPoint2D_Get(arg1);
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 resultobj = result;
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7325 PyObject *obj;
7326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7327 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7328 Py_INCREF(obj);
7329 return Py_BuildValue((char *)"");
7330 }
7331 static int _wrap_DefaultPosition_set(PyObject *) {
7332 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7333 return 1;
7334 }
7335
7336
7337 static PyObject *_wrap_DefaultPosition_get(void) {
7338 PyObject *pyobj;
7339
7340 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7341 return pyobj;
7342 }
7343
7344
7345 static int _wrap_DefaultSize_set(PyObject *) {
7346 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7347 return 1;
7348 }
7349
7350
7351 static PyObject *_wrap_DefaultSize_get(void) {
7352 PyObject *pyobj;
7353
7354 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7355 return pyobj;
7356 }
7357
7358
7359 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 PyObject *arg1 = (PyObject *) 0 ;
7362 wxPyInputStream *result;
7363 PyObject * obj0 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "p", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7369 arg1 = obj0;
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7373
7374 wxPyEndAllowThreads(__tstate);
7375 if (PyErr_Occurred()) SWIG_fail;
7376 }
7377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj;
7386 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7387 PyObject * obj0 = 0 ;
7388 char *kwnames[] = {
7389 (char *) "self", NULL
7390 };
7391
7392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7394 if (SWIG_arg_fail(1)) SWIG_fail;
7395 {
7396 PyThreadState* __tstate = wxPyBeginAllowThreads();
7397 delete arg1;
7398
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 Py_INCREF(Py_None); resultobj = Py_None;
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj;
7411 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7412 PyObject * obj0 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->close();
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 Py_INCREF(Py_None); resultobj = Py_None;
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7437 PyObject * obj0 = 0 ;
7438 char *kwnames[] = {
7439 (char *) "self", NULL
7440 };
7441
7442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7444 if (SWIG_arg_fail(1)) SWIG_fail;
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 (arg1)->flush();
7448
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 Py_INCREF(Py_None); resultobj = Py_None;
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7462 bool result;
7463 PyObject * obj0 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->eof();
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj;
7489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7490 int arg2 = (int) -1 ;
7491 PyObject *result;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char *kwnames[] = {
7495 (char *) "self",(char *) "size", NULL
7496 };
7497
7498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7500 if (SWIG_arg_fail(1)) SWIG_fail;
7501 if (obj1) {
7502 {
7503 arg2 = (int)(SWIG_As_int(obj1));
7504 if (SWIG_arg_fail(2)) SWIG_fail;
7505 }
7506 }
7507 {
7508 PyThreadState* __tstate = wxPyBeginAllowThreads();
7509 result = (PyObject *)(arg1)->read(arg2);
7510
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 resultobj = result;
7515 return resultobj;
7516 fail:
7517 return NULL;
7518 }
7519
7520
7521 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7524 int arg2 = (int) -1 ;
7525 PyObject *result;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self",(char *) "size", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 if (obj1) {
7536 {
7537 arg2 = (int)(SWIG_As_int(obj1));
7538 if (SWIG_arg_fail(2)) SWIG_fail;
7539 }
7540 }
7541 {
7542 PyThreadState* __tstate = wxPyBeginAllowThreads();
7543 result = (PyObject *)(arg1)->readline(arg2);
7544
7545 wxPyEndAllowThreads(__tstate);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = result;
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj;
7557 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7558 int arg2 = (int) -1 ;
7559 PyObject *result;
7560 PyObject * obj0 = 0 ;
7561 PyObject * obj1 = 0 ;
7562 char *kwnames[] = {
7563 (char *) "self",(char *) "sizehint", NULL
7564 };
7565
7566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7568 if (SWIG_arg_fail(1)) SWIG_fail;
7569 if (obj1) {
7570 {
7571 arg2 = (int)(SWIG_As_int(obj1));
7572 if (SWIG_arg_fail(2)) SWIG_fail;
7573 }
7574 }
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 result = (PyObject *)(arg1)->readlines(arg2);
7578
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = result;
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7592 int arg2 ;
7593 int arg3 = (int) 0 ;
7594 PyObject * obj0 = 0 ;
7595 PyObject * obj1 = 0 ;
7596 PyObject * obj2 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self",(char *) "offset",(char *) "whence", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 {
7605 arg2 = (int)(SWIG_As_int(obj1));
7606 if (SWIG_arg_fail(2)) SWIG_fail;
7607 }
7608 if (obj2) {
7609 {
7610 arg3 = (int)(SWIG_As_int(obj2));
7611 if (SWIG_arg_fail(3)) SWIG_fail;
7612 }
7613 }
7614 {
7615 PyThreadState* __tstate = wxPyBeginAllowThreads();
7616 (arg1)->seek(arg2,arg3);
7617
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 Py_INCREF(Py_None); resultobj = Py_None;
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7629 PyObject *resultobj;
7630 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7631 int result;
7632 PyObject * obj0 = 0 ;
7633 char *kwnames[] = {
7634 (char *) "self", NULL
7635 };
7636
7637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7639 if (SWIG_arg_fail(1)) SWIG_fail;
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 result = (int)(arg1)->tell();
7643
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 {
7648 resultobj = SWIG_From_int((int)(result));
7649 }
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj;
7658 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7659 char result;
7660 PyObject * obj0 = 0 ;
7661 char *kwnames[] = {
7662 (char *) "self", NULL
7663 };
7664
7665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7667 if (SWIG_arg_fail(1)) SWIG_fail;
7668 {
7669 PyThreadState* __tstate = wxPyBeginAllowThreads();
7670 result = (char)(arg1)->Peek();
7671
7672 wxPyEndAllowThreads(__tstate);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 {
7676 resultobj = SWIG_From_char((char)(result));
7677 }
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7685 PyObject *resultobj;
7686 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7687 char result;
7688 PyObject * obj0 = 0 ;
7689 char *kwnames[] = {
7690 (char *) "self", NULL
7691 };
7692
7693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7695 if (SWIG_arg_fail(1)) SWIG_fail;
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (char)(arg1)->GetC();
7699
7700 wxPyEndAllowThreads(__tstate);
7701 if (PyErr_Occurred()) SWIG_fail;
7702 }
7703 {
7704 resultobj = SWIG_From_char((char)(result));
7705 }
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7715 size_t result;
7716 PyObject * obj0 = 0 ;
7717 char *kwnames[] = {
7718 (char *) "self", NULL
7719 };
7720
7721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7723 if (SWIG_arg_fail(1)) SWIG_fail;
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 result = (size_t)(arg1)->LastRead();
7727
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 {
7732 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7733 }
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj;
7742 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7743 bool result;
7744 PyObject * obj0 = 0 ;
7745 char *kwnames[] = {
7746 (char *) "self", NULL
7747 };
7748
7749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7751 if (SWIG_arg_fail(1)) SWIG_fail;
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (bool)(arg1)->CanRead();
7755
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj;
7770 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7771 bool result;
7772 PyObject * obj0 = 0 ;
7773 char *kwnames[] = {
7774 (char *) "self", NULL
7775 };
7776
7777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7779 if (SWIG_arg_fail(1)) SWIG_fail;
7780 {
7781 PyThreadState* __tstate = wxPyBeginAllowThreads();
7782 result = (bool)(arg1)->Eof();
7783
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 {
7788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7789 }
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj;
7798 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7799 char arg2 ;
7800 bool result;
7801 PyObject * obj0 = 0 ;
7802 PyObject * obj1 = 0 ;
7803 char *kwnames[] = {
7804 (char *) "self",(char *) "c", NULL
7805 };
7806
7807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7809 if (SWIG_arg_fail(1)) SWIG_fail;
7810 {
7811 arg2 = (char)(SWIG_As_char(obj1));
7812 if (SWIG_arg_fail(2)) SWIG_fail;
7813 }
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 result = (bool)(arg1)->Ungetch(arg2);
7817
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7831 PyObject *resultobj;
7832 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7833 long arg2 ;
7834 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7835 long result;
7836 PyObject * obj0 = 0 ;
7837 PyObject * obj1 = 0 ;
7838 PyObject * obj2 = 0 ;
7839 char *kwnames[] = {
7840 (char *) "self",(char *) "pos",(char *) "mode", NULL
7841 };
7842
7843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7845 if (SWIG_arg_fail(1)) SWIG_fail;
7846 {
7847 arg2 = (long)(SWIG_As_long(obj1));
7848 if (SWIG_arg_fail(2)) SWIG_fail;
7849 }
7850 if (obj2) {
7851 {
7852 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7853 if (SWIG_arg_fail(3)) SWIG_fail;
7854 }
7855 }
7856 {
7857 PyThreadState* __tstate = wxPyBeginAllowThreads();
7858 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7859
7860 wxPyEndAllowThreads(__tstate);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 {
7864 resultobj = SWIG_From_long((long)(result));
7865 }
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7875 long result;
7876 PyObject * obj0 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 result = (long)(arg1)->TellI();
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 {
7892 resultobj = SWIG_From_long((long)(result));
7893 }
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7901 PyObject *obj;
7902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7903 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7904 Py_INCREF(obj);
7905 return Py_BuildValue((char *)"");
7906 }
7907 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7908 PyObject *resultobj;
7909 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7910 PyObject *arg2 = (PyObject *) 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 char *kwnames[] = {
7914 (char *) "self",(char *) "obj", NULL
7915 };
7916
7917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7919 if (SWIG_arg_fail(1)) SWIG_fail;
7920 arg2 = obj1;
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 wxOutputStream_write(arg1,arg2);
7924
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 Py_INCREF(Py_None); resultobj = Py_None;
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7936 PyObject *obj;
7937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7938 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7939 Py_INCREF(obj);
7940 return Py_BuildValue((char *)"");
7941 }
7942 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7943 PyObject *resultobj;
7944 wxInputStream *arg1 = (wxInputStream *) 0 ;
7945 wxString *arg2 = 0 ;
7946 wxString *arg3 = 0 ;
7947 wxString *arg4 = 0 ;
7948 wxDateTime arg5 ;
7949 wxFSFile *result;
7950 wxPyInputStream *temp1 ;
7951 bool temp2 = false ;
7952 bool temp3 = false ;
7953 bool temp4 = false ;
7954 PyObject * obj0 = 0 ;
7955 PyObject * obj1 = 0 ;
7956 PyObject * obj2 = 0 ;
7957 PyObject * obj3 = 0 ;
7958 PyObject * obj4 = 0 ;
7959 char *kwnames[] = {
7960 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7961 };
7962
7963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7964 {
7965 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7966 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7967 } else {
7968 PyErr_Clear(); // clear the failure of the wxPyConvert above
7969 arg1 = wxPyCBInputStream_create(obj0, true);
7970 if (arg1 == NULL) {
7971 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7972 SWIG_fail;
7973 }
7974 }
7975 }
7976 {
7977 arg2 = wxString_in_helper(obj1);
7978 if (arg2 == NULL) SWIG_fail;
7979 temp2 = true;
7980 }
7981 {
7982 arg3 = wxString_in_helper(obj2);
7983 if (arg3 == NULL) SWIG_fail;
7984 temp3 = true;
7985 }
7986 {
7987 arg4 = wxString_in_helper(obj3);
7988 if (arg4 == NULL) SWIG_fail;
7989 temp4 = true;
7990 }
7991 {
7992 wxDateTime * argp;
7993 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7994 if (SWIG_arg_fail(5)) SWIG_fail;
7995 if (argp == NULL) {
7996 SWIG_null_ref("wxDateTime");
7997 }
7998 if (SWIG_arg_fail(5)) SWIG_fail;
7999 arg5 = *argp;
8000 }
8001 {
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8004
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 {
8009 resultobj = wxPyMake_wxObject(result, 1);
8010 }
8011 {
8012 if (temp2)
8013 delete arg2;
8014 }
8015 {
8016 if (temp3)
8017 delete arg3;
8018 }
8019 {
8020 if (temp4)
8021 delete arg4;
8022 }
8023 return resultobj;
8024 fail:
8025 {
8026 if (temp2)
8027 delete arg2;
8028 }
8029 {
8030 if (temp3)
8031 delete arg3;
8032 }
8033 {
8034 if (temp4)
8035 delete arg4;
8036 }
8037 return NULL;
8038 }
8039
8040
8041 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8042 PyObject *resultobj;
8043 wxFSFile *arg1 = (wxFSFile *) 0 ;
8044 PyObject * obj0 = 0 ;
8045 char *kwnames[] = {
8046 (char *) "self", NULL
8047 };
8048
8049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8051 if (SWIG_arg_fail(1)) SWIG_fail;
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 delete arg1;
8055
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 Py_INCREF(Py_None); resultobj = Py_None;
8060 return resultobj;
8061 fail:
8062 return NULL;
8063 }
8064
8065
8066 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8067 PyObject *resultobj;
8068 wxFSFile *arg1 = (wxFSFile *) 0 ;
8069 wxInputStream *result;
8070 PyObject * obj0 = 0 ;
8071 char *kwnames[] = {
8072 (char *) "self", NULL
8073 };
8074
8075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8077 if (SWIG_arg_fail(1)) SWIG_fail;
8078 {
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 result = (wxInputStream *)(arg1)->GetStream();
8081
8082 wxPyEndAllowThreads(__tstate);
8083 if (PyErr_Occurred()) SWIG_fail;
8084 }
8085 {
8086 wxPyInputStream * _ptr = NULL;
8087
8088 if (result) {
8089 _ptr = new wxPyInputStream(result);
8090 }
8091 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8092 }
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8100 PyObject *resultobj;
8101 wxFSFile *arg1 = (wxFSFile *) 0 ;
8102 wxString *result;
8103 PyObject * obj0 = 0 ;
8104 char *kwnames[] = {
8105 (char *) "self", NULL
8106 };
8107
8108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8110 if (SWIG_arg_fail(1)) SWIG_fail;
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 {
8114 wxString const &_result_ref = (arg1)->GetMimeType();
8115 result = (wxString *) &_result_ref;
8116 }
8117
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 {
8122 #if wxUSE_UNICODE
8123 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8124 #else
8125 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8126 #endif
8127 }
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8135 PyObject *resultobj;
8136 wxFSFile *arg1 = (wxFSFile *) 0 ;
8137 wxString *result;
8138 PyObject * obj0 = 0 ;
8139 char *kwnames[] = {
8140 (char *) "self", NULL
8141 };
8142
8143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8145 if (SWIG_arg_fail(1)) SWIG_fail;
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 {
8149 wxString const &_result_ref = (arg1)->GetLocation();
8150 result = (wxString *) &_result_ref;
8151 }
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 #if wxUSE_UNICODE
8158 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8159 #else
8160 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8161 #endif
8162 }
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj;
8171 wxFSFile *arg1 = (wxFSFile *) 0 ;
8172 wxString *result;
8173 PyObject * obj0 = 0 ;
8174 char *kwnames[] = {
8175 (char *) "self", NULL
8176 };
8177
8178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8180 if (SWIG_arg_fail(1)) SWIG_fail;
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 {
8184 wxString const &_result_ref = (arg1)->GetAnchor();
8185 result = (wxString *) &_result_ref;
8186 }
8187
8188 wxPyEndAllowThreads(__tstate);
8189 if (PyErr_Occurred()) SWIG_fail;
8190 }
8191 {
8192 #if wxUSE_UNICODE
8193 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8194 #else
8195 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8196 #endif
8197 }
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj;
8206 wxFSFile *arg1 = (wxFSFile *) 0 ;
8207 wxDateTime result;
8208 PyObject * obj0 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "self", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (arg1)->GetModificationTime();
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 {
8224 wxDateTime * resultptr;
8225 resultptr = new wxDateTime((wxDateTime &)(result));
8226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8227 }
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8235 PyObject *obj;
8236 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8237 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8238 Py_INCREF(obj);
8239 return Py_BuildValue((char *)"");
8240 }
8241 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8242 PyObject *obj;
8243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8244 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8245 Py_INCREF(obj);
8246 return Py_BuildValue((char *)"");
8247 }
8248 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *result;
8251 char *kwnames[] = {
8252 NULL
8253 };
8254
8255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8256 {
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8259
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj;
8272 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8273 PyObject *arg2 = (PyObject *) 0 ;
8274 PyObject *arg3 = (PyObject *) 0 ;
8275 PyObject * obj0 = 0 ;
8276 PyObject * obj1 = 0 ;
8277 PyObject * obj2 = 0 ;
8278 char *kwnames[] = {
8279 (char *) "self",(char *) "self",(char *) "_class", NULL
8280 };
8281
8282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8284 if (SWIG_arg_fail(1)) SWIG_fail;
8285 arg2 = obj1;
8286 arg3 = obj2;
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 (arg1)->_setCallbackInfo(arg2,arg3);
8290
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 Py_INCREF(Py_None); resultobj = Py_None;
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj;
8303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8304 wxString *arg2 = 0 ;
8305 bool result;
8306 bool temp2 = false ;
8307 PyObject * obj0 = 0 ;
8308 PyObject * obj1 = 0 ;
8309 char *kwnames[] = {
8310 (char *) "self",(char *) "location", NULL
8311 };
8312
8313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8315 if (SWIG_arg_fail(1)) SWIG_fail;
8316 {
8317 arg2 = wxString_in_helper(obj1);
8318 if (arg2 == NULL) SWIG_fail;
8319 temp2 = true;
8320 }
8321 {
8322 PyThreadState* __tstate = wxPyBeginAllowThreads();
8323 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8324
8325 wxPyEndAllowThreads(__tstate);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 {
8329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8330 }
8331 {
8332 if (temp2)
8333 delete arg2;
8334 }
8335 return resultobj;
8336 fail:
8337 {
8338 if (temp2)
8339 delete arg2;
8340 }
8341 return NULL;
8342 }
8343
8344
8345 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj;
8347 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8348 wxFileSystem *arg2 = 0 ;
8349 wxString *arg3 = 0 ;
8350 wxFSFile *result;
8351 bool temp3 = false ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 PyObject * obj2 = 0 ;
8355 char *kwnames[] = {
8356 (char *) "self",(char *) "fs",(char *) "location", NULL
8357 };
8358
8359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8361 if (SWIG_arg_fail(1)) SWIG_fail;
8362 {
8363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(2)) SWIG_fail;
8365 if (arg2 == NULL) {
8366 SWIG_null_ref("wxFileSystem");
8367 }
8368 if (SWIG_arg_fail(2)) SWIG_fail;
8369 }
8370 {
8371 arg3 = wxString_in_helper(obj2);
8372 if (arg3 == NULL) SWIG_fail;
8373 temp3 = true;
8374 }
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8378
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 {
8383 resultobj = wxPyMake_wxObject(result, 1);
8384 }
8385 {
8386 if (temp3)
8387 delete arg3;
8388 }
8389 return resultobj;
8390 fail:
8391 {
8392 if (temp3)
8393 delete arg3;
8394 }
8395 return NULL;
8396 }
8397
8398
8399 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8400 PyObject *resultobj;
8401 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8402 wxString *arg2 = 0 ;
8403 int arg3 = (int) 0 ;
8404 wxString result;
8405 bool temp2 = false ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 PyObject * obj2 = 0 ;
8409 char *kwnames[] = {
8410 (char *) "self",(char *) "spec",(char *) "flags", NULL
8411 };
8412
8413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8415 if (SWIG_arg_fail(1)) SWIG_fail;
8416 {
8417 arg2 = wxString_in_helper(obj1);
8418 if (arg2 == NULL) SWIG_fail;
8419 temp2 = true;
8420 }
8421 if (obj2) {
8422 {
8423 arg3 = (int)(SWIG_As_int(obj2));
8424 if (SWIG_arg_fail(3)) SWIG_fail;
8425 }
8426 }
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8430
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 {
8435 #if wxUSE_UNICODE
8436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8437 #else
8438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8439 #endif
8440 }
8441 {
8442 if (temp2)
8443 delete arg2;
8444 }
8445 return resultobj;
8446 fail:
8447 {
8448 if (temp2)
8449 delete arg2;
8450 }
8451 return NULL;
8452 }
8453
8454
8455 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8456 PyObject *resultobj;
8457 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8458 wxString result;
8459 PyObject * obj0 = 0 ;
8460 char *kwnames[] = {
8461 (char *) "self", NULL
8462 };
8463
8464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8466 if (SWIG_arg_fail(1)) SWIG_fail;
8467 {
8468 PyThreadState* __tstate = wxPyBeginAllowThreads();
8469 result = (arg1)->FindNext();
8470
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 {
8475 #if wxUSE_UNICODE
8476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8477 #else
8478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8479 #endif
8480 }
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8488 PyObject *resultobj;
8489 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8490 wxString *arg2 = 0 ;
8491 wxString result;
8492 bool temp2 = false ;
8493 PyObject * obj0 = 0 ;
8494 PyObject * obj1 = 0 ;
8495 char *kwnames[] = {
8496 (char *) "self",(char *) "location", NULL
8497 };
8498
8499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8501 if (SWIG_arg_fail(1)) SWIG_fail;
8502 {
8503 arg2 = wxString_in_helper(obj1);
8504 if (arg2 == NULL) SWIG_fail;
8505 temp2 = true;
8506 }
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (arg1)->GetProtocol((wxString const &)*arg2);
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 {
8515 #if wxUSE_UNICODE
8516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8517 #else
8518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8519 #endif
8520 }
8521 {
8522 if (temp2)
8523 delete arg2;
8524 }
8525 return resultobj;
8526 fail:
8527 {
8528 if (temp2)
8529 delete arg2;
8530 }
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj;
8537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8538 wxString *arg2 = 0 ;
8539 wxString result;
8540 bool temp2 = false ;
8541 PyObject * obj0 = 0 ;
8542 PyObject * obj1 = 0 ;
8543 char *kwnames[] = {
8544 (char *) "self",(char *) "location", NULL
8545 };
8546
8547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8549 if (SWIG_arg_fail(1)) SWIG_fail;
8550 {
8551 arg2 = wxString_in_helper(obj1);
8552 if (arg2 == NULL) SWIG_fail;
8553 temp2 = true;
8554 }
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 #if wxUSE_UNICODE
8564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8565 #else
8566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8567 #endif
8568 }
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return resultobj;
8574 fail:
8575 {
8576 if (temp2)
8577 delete arg2;
8578 }
8579 return NULL;
8580 }
8581
8582
8583 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj;
8585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8586 wxString *arg2 = 0 ;
8587 wxString result;
8588 bool temp2 = false ;
8589 PyObject * obj0 = 0 ;
8590 PyObject * obj1 = 0 ;
8591 char *kwnames[] = {
8592 (char *) "self",(char *) "location", NULL
8593 };
8594
8595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8597 if (SWIG_arg_fail(1)) SWIG_fail;
8598 {
8599 arg2 = wxString_in_helper(obj1);
8600 if (arg2 == NULL) SWIG_fail;
8601 temp2 = true;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 result = (arg1)->GetAnchor((wxString const &)*arg2);
8606
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 {
8611 #if wxUSE_UNICODE
8612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8613 #else
8614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8615 #endif
8616 }
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return resultobj;
8622 fail:
8623 {
8624 if (temp2)
8625 delete arg2;
8626 }
8627 return NULL;
8628 }
8629
8630
8631 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8632 PyObject *resultobj;
8633 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8634 wxString *arg2 = 0 ;
8635 wxString result;
8636 bool temp2 = false ;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "self",(char *) "location", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 {
8647 arg2 = wxString_in_helper(obj1);
8648 if (arg2 == NULL) SWIG_fail;
8649 temp2 = true;
8650 }
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8654
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 {
8659 #if wxUSE_UNICODE
8660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8661 #else
8662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8663 #endif
8664 }
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return resultobj;
8670 fail:
8671 {
8672 if (temp2)
8673 delete arg2;
8674 }
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8682 wxString *arg2 = 0 ;
8683 wxString result;
8684 bool temp2 = false ;
8685 PyObject * obj0 = 0 ;
8686 PyObject * obj1 = 0 ;
8687 char *kwnames[] = {
8688 (char *) "self",(char *) "location", NULL
8689 };
8690
8691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8693 if (SWIG_arg_fail(1)) SWIG_fail;
8694 {
8695 arg2 = wxString_in_helper(obj1);
8696 if (arg2 == NULL) SWIG_fail;
8697 temp2 = true;
8698 }
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8702
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 {
8707 #if wxUSE_UNICODE
8708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8709 #else
8710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8711 #endif
8712 }
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return resultobj;
8718 fail:
8719 {
8720 if (temp2)
8721 delete arg2;
8722 }
8723 return NULL;
8724 }
8725
8726
8727 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8728 PyObject *obj;
8729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8730 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8731 Py_INCREF(obj);
8732 return Py_BuildValue((char *)"");
8733 }
8734 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxFileSystem *result;
8737 char *kwnames[] = {
8738 NULL
8739 };
8740
8741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 result = (wxFileSystem *)new wxFileSystem();
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 {
8750 resultobj = wxPyMake_wxObject(result, 1);
8751 }
8752 return resultobj;
8753 fail:
8754 return NULL;
8755 }
8756
8757
8758 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj;
8760 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8761 PyObject * obj0 = 0 ;
8762 char *kwnames[] = {
8763 (char *) "self", NULL
8764 };
8765
8766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8768 if (SWIG_arg_fail(1)) SWIG_fail;
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 delete arg1;
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 Py_INCREF(Py_None); resultobj = Py_None;
8777 return resultobj;
8778 fail:
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8786 wxString *arg2 = 0 ;
8787 bool arg3 = (bool) false ;
8788 bool temp2 = false ;
8789 PyObject * obj0 = 0 ;
8790 PyObject * obj1 = 0 ;
8791 PyObject * obj2 = 0 ;
8792 char *kwnames[] = {
8793 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8794 };
8795
8796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8798 if (SWIG_arg_fail(1)) SWIG_fail;
8799 {
8800 arg2 = wxString_in_helper(obj1);
8801 if (arg2 == NULL) SWIG_fail;
8802 temp2 = true;
8803 }
8804 if (obj2) {
8805 {
8806 arg3 = (bool)(SWIG_As_bool(obj2));
8807 if (SWIG_arg_fail(3)) SWIG_fail;
8808 }
8809 }
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 Py_INCREF(Py_None); resultobj = Py_None;
8818 {
8819 if (temp2)
8820 delete arg2;
8821 }
8822 return resultobj;
8823 fail:
8824 {
8825 if (temp2)
8826 delete arg2;
8827 }
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj;
8834 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8835 wxString result;
8836 PyObject * obj0 = 0 ;
8837 char *kwnames[] = {
8838 (char *) "self", NULL
8839 };
8840
8841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8843 if (SWIG_arg_fail(1)) SWIG_fail;
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 result = (arg1)->GetPath();
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 {
8852 #if wxUSE_UNICODE
8853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8854 #else
8855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8856 #endif
8857 }
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8865 PyObject *resultobj;
8866 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8867 wxString *arg2 = 0 ;
8868 wxFSFile *result;
8869 bool temp2 = false ;
8870 PyObject * obj0 = 0 ;
8871 PyObject * obj1 = 0 ;
8872 char *kwnames[] = {
8873 (char *) "self",(char *) "location", NULL
8874 };
8875
8876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8878 if (SWIG_arg_fail(1)) SWIG_fail;
8879 {
8880 arg2 = wxString_in_helper(obj1);
8881 if (arg2 == NULL) SWIG_fail;
8882 temp2 = true;
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8887
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 {
8892 resultobj = wxPyMake_wxObject(result, 1);
8893 }
8894 {
8895 if (temp2)
8896 delete arg2;
8897 }
8898 return resultobj;
8899 fail:
8900 {
8901 if (temp2)
8902 delete arg2;
8903 }
8904 return NULL;
8905 }
8906
8907
8908 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj;
8910 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8911 wxString *arg2 = 0 ;
8912 int arg3 = (int) 0 ;
8913 wxString result;
8914 bool temp2 = false ;
8915 PyObject * obj0 = 0 ;
8916 PyObject * obj1 = 0 ;
8917 PyObject * obj2 = 0 ;
8918 char *kwnames[] = {
8919 (char *) "self",(char *) "spec",(char *) "flags", NULL
8920 };
8921
8922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8924 if (SWIG_arg_fail(1)) SWIG_fail;
8925 {
8926 arg2 = wxString_in_helper(obj1);
8927 if (arg2 == NULL) SWIG_fail;
8928 temp2 = true;
8929 }
8930 if (obj2) {
8931 {
8932 arg3 = (int)(SWIG_As_int(obj2));
8933 if (SWIG_arg_fail(3)) SWIG_fail;
8934 }
8935 }
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 {
8944 #if wxUSE_UNICODE
8945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8946 #else
8947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8948 #endif
8949 }
8950 {
8951 if (temp2)
8952 delete arg2;
8953 }
8954 return resultobj;
8955 fail:
8956 {
8957 if (temp2)
8958 delete arg2;
8959 }
8960 return NULL;
8961 }
8962
8963
8964 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8965 PyObject *resultobj;
8966 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8967 wxString result;
8968 PyObject * obj0 = 0 ;
8969 char *kwnames[] = {
8970 (char *) "self", NULL
8971 };
8972
8973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8975 if (SWIG_arg_fail(1)) SWIG_fail;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = (arg1)->FindNext();
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 {
8984 #if wxUSE_UNICODE
8985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8986 #else
8987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8988 #endif
8989 }
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj;
8998 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8999 PyObject * obj0 = 0 ;
9000 char *kwnames[] = {
9001 (char *) "handler", NULL
9002 };
9003
9004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9006 if (SWIG_arg_fail(1)) SWIG_fail;
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 wxFileSystem::AddHandler(arg1);
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 Py_INCREF(Py_None); resultobj = Py_None;
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 char *kwnames[] = {
9024 NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 wxFileSystem::CleanUpHandlers();
9031
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 Py_INCREF(Py_None); resultobj = Py_None;
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj;
9044 wxString *arg1 = 0 ;
9045 wxString result;
9046 bool temp1 = false ;
9047 PyObject * obj0 = 0 ;
9048 char *kwnames[] = {
9049 (char *) "filename", NULL
9050 };
9051
9052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9053 {
9054 arg1 = wxString_in_helper(obj0);
9055 if (arg1 == NULL) SWIG_fail;
9056 temp1 = true;
9057 }
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9061
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 {
9066 #if wxUSE_UNICODE
9067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9068 #else
9069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9070 #endif
9071 }
9072 {
9073 if (temp1)
9074 delete arg1;
9075 }
9076 return resultobj;
9077 fail:
9078 {
9079 if (temp1)
9080 delete arg1;
9081 }
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxString *arg1 = 0 ;
9089 wxString result;
9090 bool temp1 = false ;
9091 PyObject * obj0 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "url", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9097 {
9098 arg1 = wxString_in_helper(obj0);
9099 if (arg1 == NULL) SWIG_fail;
9100 temp1 = true;
9101 }
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 result = FileSystem_URLToFileName((wxString const &)*arg1);
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 {
9110 #if wxUSE_UNICODE
9111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9112 #else
9113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9114 #endif
9115 }
9116 {
9117 if (temp1)
9118 delete arg1;
9119 }
9120 return resultobj;
9121 fail:
9122 {
9123 if (temp1)
9124 delete arg1;
9125 }
9126 return NULL;
9127 }
9128
9129
9130 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9131 PyObject *obj;
9132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9133 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9134 Py_INCREF(obj);
9135 return Py_BuildValue((char *)"");
9136 }
9137 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxInternetFSHandler *result;
9140 char *kwnames[] = {
9141 NULL
9142 };
9143
9144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj;
9161 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9162 wxString *arg2 = 0 ;
9163 bool result;
9164 bool temp2 = false ;
9165 PyObject * obj0 = 0 ;
9166 PyObject * obj1 = 0 ;
9167 char *kwnames[] = {
9168 (char *) "self",(char *) "location", NULL
9169 };
9170
9171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9173 if (SWIG_arg_fail(1)) SWIG_fail;
9174 {
9175 arg2 = wxString_in_helper(obj1);
9176 if (arg2 == NULL) SWIG_fail;
9177 temp2 = true;
9178 }
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9182
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 {
9187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9188 }
9189 {
9190 if (temp2)
9191 delete arg2;
9192 }
9193 return resultobj;
9194 fail:
9195 {
9196 if (temp2)
9197 delete arg2;
9198 }
9199 return NULL;
9200 }
9201
9202
9203 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9204 PyObject *resultobj;
9205 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9206 wxFileSystem *arg2 = 0 ;
9207 wxString *arg3 = 0 ;
9208 wxFSFile *result;
9209 bool temp3 = false ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 PyObject * obj2 = 0 ;
9213 char *kwnames[] = {
9214 (char *) "self",(char *) "fs",(char *) "location", NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9219 if (SWIG_arg_fail(1)) SWIG_fail;
9220 {
9221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9222 if (SWIG_arg_fail(2)) SWIG_fail;
9223 if (arg2 == NULL) {
9224 SWIG_null_ref("wxFileSystem");
9225 }
9226 if (SWIG_arg_fail(2)) SWIG_fail;
9227 }
9228 {
9229 arg3 = wxString_in_helper(obj2);
9230 if (arg3 == NULL) SWIG_fail;
9231 temp3 = true;
9232 }
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 {
9241 resultobj = wxPyMake_wxObject(result, 1);
9242 }
9243 {
9244 if (temp3)
9245 delete arg3;
9246 }
9247 return resultobj;
9248 fail:
9249 {
9250 if (temp3)
9251 delete arg3;
9252 }
9253 return NULL;
9254 }
9255
9256
9257 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9258 PyObject *obj;
9259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9260 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9261 Py_INCREF(obj);
9262 return Py_BuildValue((char *)"");
9263 }
9264 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9265 PyObject *resultobj;
9266 wxZipFSHandler *result;
9267 char *kwnames[] = {
9268 NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (wxZipFSHandler *)new wxZipFSHandler();
9275
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj;
9288 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9289 wxString *arg2 = 0 ;
9290 bool result;
9291 bool temp2 = false ;
9292 PyObject * obj0 = 0 ;
9293 PyObject * obj1 = 0 ;
9294 char *kwnames[] = {
9295 (char *) "self",(char *) "location", NULL
9296 };
9297
9298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9300 if (SWIG_arg_fail(1)) SWIG_fail;
9301 {
9302 arg2 = wxString_in_helper(obj1);
9303 if (arg2 == NULL) SWIG_fail;
9304 temp2 = true;
9305 }
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 {
9314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9315 }
9316 {
9317 if (temp2)
9318 delete arg2;
9319 }
9320 return resultobj;
9321 fail:
9322 {
9323 if (temp2)
9324 delete arg2;
9325 }
9326 return NULL;
9327 }
9328
9329
9330 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj;
9332 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9333 wxFileSystem *arg2 = 0 ;
9334 wxString *arg3 = 0 ;
9335 wxFSFile *result;
9336 bool temp3 = false ;
9337 PyObject * obj0 = 0 ;
9338 PyObject * obj1 = 0 ;
9339 PyObject * obj2 = 0 ;
9340 char *kwnames[] = {
9341 (char *) "self",(char *) "fs",(char *) "location", NULL
9342 };
9343
9344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9346 if (SWIG_arg_fail(1)) SWIG_fail;
9347 {
9348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9349 if (SWIG_arg_fail(2)) SWIG_fail;
9350 if (arg2 == NULL) {
9351 SWIG_null_ref("wxFileSystem");
9352 }
9353 if (SWIG_arg_fail(2)) SWIG_fail;
9354 }
9355 {
9356 arg3 = wxString_in_helper(obj2);
9357 if (arg3 == NULL) SWIG_fail;
9358 temp3 = true;
9359 }
9360 {
9361 PyThreadState* __tstate = wxPyBeginAllowThreads();
9362 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9363
9364 wxPyEndAllowThreads(__tstate);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 {
9368 resultobj = wxPyMake_wxObject(result, 1);
9369 }
9370 {
9371 if (temp3)
9372 delete arg3;
9373 }
9374 return resultobj;
9375 fail:
9376 {
9377 if (temp3)
9378 delete arg3;
9379 }
9380 return NULL;
9381 }
9382
9383
9384 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9385 PyObject *resultobj;
9386 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9387 wxString *arg2 = 0 ;
9388 int arg3 = (int) 0 ;
9389 wxString result;
9390 bool temp2 = false ;
9391 PyObject * obj0 = 0 ;
9392 PyObject * obj1 = 0 ;
9393 PyObject * obj2 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "self",(char *) "spec",(char *) "flags", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9400 if (SWIG_arg_fail(1)) SWIG_fail;
9401 {
9402 arg2 = wxString_in_helper(obj1);
9403 if (arg2 == NULL) SWIG_fail;
9404 temp2 = true;
9405 }
9406 if (obj2) {
9407 {
9408 arg3 = (int)(SWIG_As_int(obj2));
9409 if (SWIG_arg_fail(3)) SWIG_fail;
9410 }
9411 }
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 #if wxUSE_UNICODE
9421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9422 #else
9423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9424 #endif
9425 }
9426 {
9427 if (temp2)
9428 delete arg2;
9429 }
9430 return resultobj;
9431 fail:
9432 {
9433 if (temp2)
9434 delete arg2;
9435 }
9436 return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj;
9442 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9443 wxString result;
9444 PyObject * obj0 = 0 ;
9445 char *kwnames[] = {
9446 (char *) "self", NULL
9447 };
9448
9449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9451 if (SWIG_arg_fail(1)) SWIG_fail;
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 result = (arg1)->FindNext();
9455
9456 wxPyEndAllowThreads(__tstate);
9457 if (PyErr_Occurred()) SWIG_fail;
9458 }
9459 {
9460 #if wxUSE_UNICODE
9461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9462 #else
9463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9464 #endif
9465 }
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9473 PyObject *obj;
9474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9475 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9476 Py_INCREF(obj);
9477 return Py_BuildValue((char *)"");
9478 }
9479 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj;
9481 wxString *arg1 = 0 ;
9482 wxImage *arg2 = 0 ;
9483 long arg3 ;
9484 bool temp1 = false ;
9485 PyObject * obj0 = 0 ;
9486 PyObject * obj1 = 0 ;
9487 PyObject * obj2 = 0 ;
9488 char *kwnames[] = {
9489 (char *) "filename",(char *) "image",(char *) "type", NULL
9490 };
9491
9492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9493 {
9494 arg1 = wxString_in_helper(obj0);
9495 if (arg1 == NULL) SWIG_fail;
9496 temp1 = true;
9497 }
9498 {
9499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(2)) SWIG_fail;
9501 if (arg2 == NULL) {
9502 SWIG_null_ref("wxImage");
9503 }
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 }
9506 {
9507 arg3 = (long)(SWIG_As_long(obj2));
9508 if (SWIG_arg_fail(3)) SWIG_fail;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 Py_INCREF(Py_None); resultobj = Py_None;
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp1)
9526 delete arg1;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxString *arg1 = 0 ;
9535 wxBitmap *arg2 = 0 ;
9536 long arg3 ;
9537 bool temp1 = false ;
9538 PyObject * obj0 = 0 ;
9539 PyObject * obj1 = 0 ;
9540 PyObject * obj2 = 0 ;
9541 char *kwnames[] = {
9542 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9543 };
9544
9545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9546 {
9547 arg1 = wxString_in_helper(obj0);
9548 if (arg1 == NULL) SWIG_fail;
9549 temp1 = true;
9550 }
9551 {
9552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9553 if (SWIG_arg_fail(2)) SWIG_fail;
9554 if (arg2 == NULL) {
9555 SWIG_null_ref("wxBitmap");
9556 }
9557 if (SWIG_arg_fail(2)) SWIG_fail;
9558 }
9559 {
9560 arg3 = (long)(SWIG_As_long(obj2));
9561 if (SWIG_arg_fail(3)) SWIG_fail;
9562 }
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 Py_INCREF(Py_None); resultobj = Py_None;
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return resultobj;
9576 fail:
9577 {
9578 if (temp1)
9579 delete arg1;
9580 }
9581 return NULL;
9582 }
9583
9584
9585 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj;
9587 wxString *arg1 = 0 ;
9588 PyObject *arg2 = (PyObject *) 0 ;
9589 bool temp1 = false ;
9590 PyObject * obj0 = 0 ;
9591 PyObject * obj1 = 0 ;
9592 char *kwnames[] = {
9593 (char *) "filename",(char *) "data", NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9597 {
9598 arg1 = wxString_in_helper(obj0);
9599 if (arg1 == NULL) SWIG_fail;
9600 temp1 = true;
9601 }
9602 arg2 = obj1;
9603 {
9604 PyThreadState* __tstate = wxPyBeginAllowThreads();
9605 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9606
9607 wxPyEndAllowThreads(__tstate);
9608 if (PyErr_Occurred()) SWIG_fail;
9609 }
9610 Py_INCREF(Py_None); resultobj = Py_None;
9611 {
9612 if (temp1)
9613 delete arg1;
9614 }
9615 return resultobj;
9616 fail:
9617 {
9618 if (temp1)
9619 delete arg1;
9620 }
9621 return NULL;
9622 }
9623
9624
9625 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxMemoryFSHandler *result;
9628 char *kwnames[] = {
9629 NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9636
9637 wxPyEndAllowThreads(__tstate);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9648 PyObject *resultobj;
9649 wxString *arg1 = 0 ;
9650 bool temp1 = false ;
9651 PyObject * obj0 = 0 ;
9652 char *kwnames[] = {
9653 (char *) "filename", NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9657 {
9658 arg1 = wxString_in_helper(obj0);
9659 if (arg1 == NULL) SWIG_fail;
9660 temp1 = true;
9661 }
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9665
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 Py_INCREF(Py_None); resultobj = Py_None;
9670 {
9671 if (temp1)
9672 delete arg1;
9673 }
9674 return resultobj;
9675 fail:
9676 {
9677 if (temp1)
9678 delete arg1;
9679 }
9680 return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj;
9686 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9687 wxString *arg2 = 0 ;
9688 bool result;
9689 bool temp2 = false ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9692 char *kwnames[] = {
9693 (char *) "self",(char *) "location", NULL
9694 };
9695
9696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(1)) SWIG_fail;
9699 {
9700 arg2 = wxString_in_helper(obj1);
9701 if (arg2 == NULL) SWIG_fail;
9702 temp2 = true;
9703 }
9704 {
9705 PyThreadState* __tstate = wxPyBeginAllowThreads();
9706 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9707
9708 wxPyEndAllowThreads(__tstate);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 {
9712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9713 }
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 return resultobj;
9719 fail:
9720 {
9721 if (temp2)
9722 delete arg2;
9723 }
9724 return NULL;
9725 }
9726
9727
9728 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9729 PyObject *resultobj;
9730 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9731 wxFileSystem *arg2 = 0 ;
9732 wxString *arg3 = 0 ;
9733 wxFSFile *result;
9734 bool temp3 = false ;
9735 PyObject * obj0 = 0 ;
9736 PyObject * obj1 = 0 ;
9737 PyObject * obj2 = 0 ;
9738 char *kwnames[] = {
9739 (char *) "self",(char *) "fs",(char *) "location", NULL
9740 };
9741
9742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9744 if (SWIG_arg_fail(1)) SWIG_fail;
9745 {
9746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(2)) SWIG_fail;
9748 if (arg2 == NULL) {
9749 SWIG_null_ref("wxFileSystem");
9750 }
9751 if (SWIG_arg_fail(2)) SWIG_fail;
9752 }
9753 {
9754 arg3 = wxString_in_helper(obj2);
9755 if (arg3 == NULL) SWIG_fail;
9756 temp3 = true;
9757 }
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 {
9766 resultobj = wxPyMake_wxObject(result, 1);
9767 }
9768 {
9769 if (temp3)
9770 delete arg3;
9771 }
9772 return resultobj;
9773 fail:
9774 {
9775 if (temp3)
9776 delete arg3;
9777 }
9778 return NULL;
9779 }
9780
9781
9782 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9783 PyObject *resultobj;
9784 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9785 wxString *arg2 = 0 ;
9786 int arg3 = (int) 0 ;
9787 wxString result;
9788 bool temp2 = false ;
9789 PyObject * obj0 = 0 ;
9790 PyObject * obj1 = 0 ;
9791 PyObject * obj2 = 0 ;
9792 char *kwnames[] = {
9793 (char *) "self",(char *) "spec",(char *) "flags", NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(1)) SWIG_fail;
9799 {
9800 arg2 = wxString_in_helper(obj1);
9801 if (arg2 == NULL) SWIG_fail;
9802 temp2 = true;
9803 }
9804 if (obj2) {
9805 {
9806 arg3 = (int)(SWIG_As_int(obj2));
9807 if (SWIG_arg_fail(3)) SWIG_fail;
9808 }
9809 }
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 {
9818 #if wxUSE_UNICODE
9819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9820 #else
9821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9822 #endif
9823 }
9824 {
9825 if (temp2)
9826 delete arg2;
9827 }
9828 return resultobj;
9829 fail:
9830 {
9831 if (temp2)
9832 delete arg2;
9833 }
9834 return NULL;
9835 }
9836
9837
9838 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9839 PyObject *resultobj;
9840 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9841 wxString result;
9842 PyObject * obj0 = 0 ;
9843 char *kwnames[] = {
9844 (char *) "self", NULL
9845 };
9846
9847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9849 if (SWIG_arg_fail(1)) SWIG_fail;
9850 {
9851 PyThreadState* __tstate = wxPyBeginAllowThreads();
9852 result = (arg1)->FindNext();
9853
9854 wxPyEndAllowThreads(__tstate);
9855 if (PyErr_Occurred()) SWIG_fail;
9856 }
9857 {
9858 #if wxUSE_UNICODE
9859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9860 #else
9861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9862 #endif
9863 }
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9871 PyObject *obj;
9872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9873 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9874 Py_INCREF(obj);
9875 return Py_BuildValue((char *)"");
9876 }
9877 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9878 PyObject *resultobj;
9879 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9880 wxString result;
9881 PyObject * obj0 = 0 ;
9882 char *kwnames[] = {
9883 (char *) "self", NULL
9884 };
9885
9886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9888 if (SWIG_arg_fail(1)) SWIG_fail;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 result = (arg1)->GetName();
9892
9893 wxPyEndAllowThreads(__tstate);
9894 if (PyErr_Occurred()) SWIG_fail;
9895 }
9896 {
9897 #if wxUSE_UNICODE
9898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9899 #else
9900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9901 #endif
9902 }
9903 return resultobj;
9904 fail:
9905 return NULL;
9906 }
9907
9908
9909 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9910 PyObject *resultobj;
9911 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9912 wxString result;
9913 PyObject * obj0 = 0 ;
9914 char *kwnames[] = {
9915 (char *) "self", NULL
9916 };
9917
9918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9920 if (SWIG_arg_fail(1)) SWIG_fail;
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (arg1)->GetExtension();
9924
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 {
9929 #if wxUSE_UNICODE
9930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9931 #else
9932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9933 #endif
9934 }
9935 return resultobj;
9936 fail:
9937 return NULL;
9938 }
9939
9940
9941 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj;
9943 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9944 long result;
9945 PyObject * obj0 = 0 ;
9946 char *kwnames[] = {
9947 (char *) "self", NULL
9948 };
9949
9950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9952 if (SWIG_arg_fail(1)) SWIG_fail;
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (long)(arg1)->GetType();
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 {
9961 resultobj = SWIG_From_long((long)(result));
9962 }
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9970 PyObject *resultobj;
9971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9972 wxString result;
9973 PyObject * obj0 = 0 ;
9974 char *kwnames[] = {
9975 (char *) "self", NULL
9976 };
9977
9978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9980 if (SWIG_arg_fail(1)) SWIG_fail;
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (arg1)->GetMimeType();
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 {
9989 #if wxUSE_UNICODE
9990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9991 #else
9992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9993 #endif
9994 }
9995 return resultobj;
9996 fail:
9997 return NULL;
9998 }
9999
10000
10001 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj;
10003 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10004 wxString *arg2 = 0 ;
10005 bool result;
10006 bool temp2 = false ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self",(char *) "name", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 arg2 = wxString_in_helper(obj1);
10018 if (arg2 == NULL) SWIG_fail;
10019 temp2 = true;
10020 }
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10024
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 {
10029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10030 }
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 return NULL;
10042 }
10043
10044
10045 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj;
10047 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10048 wxString *arg2 = 0 ;
10049 bool temp2 = false ;
10050 PyObject * obj0 = 0 ;
10051 PyObject * obj1 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "self",(char *) "name", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 {
10060 arg2 = wxString_in_helper(obj1);
10061 if (arg2 == NULL) SWIG_fail;
10062 temp2 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 (arg1)->SetName((wxString const &)*arg2);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10089 wxString *arg2 = 0 ;
10090 bool temp2 = false ;
10091 PyObject * obj0 = 0 ;
10092 PyObject * obj1 = 0 ;
10093 char *kwnames[] = {
10094 (char *) "self",(char *) "extension", NULL
10095 };
10096
10097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10099 if (SWIG_arg_fail(1)) SWIG_fail;
10100 {
10101 arg2 = wxString_in_helper(obj1);
10102 if (arg2 == NULL) SWIG_fail;
10103 temp2 = true;
10104 }
10105 {
10106 PyThreadState* __tstate = wxPyBeginAllowThreads();
10107 (arg1)->SetExtension((wxString const &)*arg2);
10108
10109 wxPyEndAllowThreads(__tstate);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 Py_INCREF(Py_None); resultobj = Py_None;
10113 {
10114 if (temp2)
10115 delete arg2;
10116 }
10117 return resultobj;
10118 fail:
10119 {
10120 if (temp2)
10121 delete arg2;
10122 }
10123 return NULL;
10124 }
10125
10126
10127 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10128 PyObject *resultobj;
10129 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10130 long arg2 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char *kwnames[] = {
10134 (char *) "self",(char *) "type", NULL
10135 };
10136
10137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10139 if (SWIG_arg_fail(1)) SWIG_fail;
10140 {
10141 arg2 = (long)(SWIG_As_long(obj1));
10142 if (SWIG_arg_fail(2)) SWIG_fail;
10143 }
10144 {
10145 PyThreadState* __tstate = wxPyBeginAllowThreads();
10146 (arg1)->SetType(arg2);
10147
10148 wxPyEndAllowThreads(__tstate);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 Py_INCREF(Py_None); resultobj = Py_None;
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10161 wxString *arg2 = 0 ;
10162 bool temp2 = false ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "self",(char *) "mimetype", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10171 if (SWIG_arg_fail(1)) SWIG_fail;
10172 {
10173 arg2 = wxString_in_helper(obj1);
10174 if (arg2 == NULL) SWIG_fail;
10175 temp2 = true;
10176 }
10177 {
10178 PyThreadState* __tstate = wxPyBeginAllowThreads();
10179 (arg1)->SetMimeType((wxString const &)*arg2);
10180
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 Py_INCREF(Py_None); resultobj = Py_None;
10185 {
10186 if (temp2)
10187 delete arg2;
10188 }
10189 return resultobj;
10190 fail:
10191 {
10192 if (temp2)
10193 delete arg2;
10194 }
10195 return NULL;
10196 }
10197
10198
10199 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10200 PyObject *obj;
10201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10202 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10203 Py_INCREF(obj);
10204 return Py_BuildValue((char *)"");
10205 }
10206 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 wxImageHistogram *result;
10209 char *kwnames[] = {
10210 NULL
10211 };
10212
10213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (wxImageHistogram *)new wxImageHistogram();
10217
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10222 return resultobj;
10223 fail:
10224 return NULL;
10225 }
10226
10227
10228 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj;
10230 unsigned char arg1 ;
10231 unsigned char arg2 ;
10232 unsigned char arg3 ;
10233 unsigned long result;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 PyObject * obj2 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "r",(char *) "g",(char *) "b", NULL
10239 };
10240
10241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10242 {
10243 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10244 if (SWIG_arg_fail(1)) SWIG_fail;
10245 }
10246 {
10247 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10248 if (SWIG_arg_fail(2)) SWIG_fail;
10249 }
10250 {
10251 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10252 if (SWIG_arg_fail(3)) SWIG_fail;
10253 }
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10257
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 {
10262 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10263 }
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10271 PyObject *resultobj;
10272 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10273 unsigned char *arg2 = (unsigned char *) 0 ;
10274 unsigned char *arg3 = (unsigned char *) 0 ;
10275 unsigned char *arg4 = (unsigned char *) 0 ;
10276 unsigned char arg5 = (unsigned char) 1 ;
10277 unsigned char arg6 = (unsigned char) 0 ;
10278 unsigned char arg7 = (unsigned char) 0 ;
10279 bool result;
10280 unsigned char temp2 ;
10281 int res2 = 0 ;
10282 unsigned char temp3 ;
10283 int res3 = 0 ;
10284 unsigned char temp4 ;
10285 int res4 = 0 ;
10286 PyObject * obj0 = 0 ;
10287 PyObject * obj1 = 0 ;
10288 PyObject * obj2 = 0 ;
10289 PyObject * obj3 = 0 ;
10290 char *kwnames[] = {
10291 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10292 };
10293
10294 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10295 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10296 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10299 if (SWIG_arg_fail(1)) SWIG_fail;
10300 if (obj1) {
10301 {
10302 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10303 if (SWIG_arg_fail(5)) SWIG_fail;
10304 }
10305 }
10306 if (obj2) {
10307 {
10308 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10309 if (SWIG_arg_fail(6)) SWIG_fail;
10310 }
10311 }
10312 if (obj3) {
10313 {
10314 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10315 if (SWIG_arg_fail(7)) SWIG_fail;
10316 }
10317 }
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10321
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10327 }
10328 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10329 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10330 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10331 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10332 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10333 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10334 return resultobj;
10335 fail:
10336 return NULL;
10337 }
10338
10339
10340 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10341 PyObject *resultobj;
10342 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10343 unsigned long arg2 ;
10344 unsigned long result;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 char *kwnames[] = {
10348 (char *) "self",(char *) "key", NULL
10349 };
10350
10351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10353 if (SWIG_arg_fail(1)) SWIG_fail;
10354 {
10355 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10356 if (SWIG_arg_fail(2)) SWIG_fail;
10357 }
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10361
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10367 }
10368 return resultobj;
10369 fail:
10370 return NULL;
10371 }
10372
10373
10374 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj;
10376 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10377 unsigned char arg2 ;
10378 unsigned char arg3 ;
10379 unsigned char arg4 ;
10380 unsigned long result;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 PyObject * obj2 = 0 ;
10384 PyObject * obj3 = 0 ;
10385 char *kwnames[] = {
10386 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10387 };
10388
10389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10391 if (SWIG_arg_fail(1)) SWIG_fail;
10392 {
10393 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10394 if (SWIG_arg_fail(2)) SWIG_fail;
10395 }
10396 {
10397 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10398 if (SWIG_arg_fail(3)) SWIG_fail;
10399 }
10400 {
10401 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10402 if (SWIG_arg_fail(4)) SWIG_fail;
10403 }
10404 {
10405 PyThreadState* __tstate = wxPyBeginAllowThreads();
10406 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10407
10408 wxPyEndAllowThreads(__tstate);
10409 if (PyErr_Occurred()) SWIG_fail;
10410 }
10411 {
10412 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10413 }
10414 return resultobj;
10415 fail:
10416 return NULL;
10417 }
10418
10419
10420 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10421 PyObject *resultobj;
10422 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10423 wxColour *arg2 = 0 ;
10424 unsigned long result;
10425 wxColour temp2 ;
10426 PyObject * obj0 = 0 ;
10427 PyObject * obj1 = 0 ;
10428 char *kwnames[] = {
10429 (char *) "self",(char *) "colour", NULL
10430 };
10431
10432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10434 if (SWIG_arg_fail(1)) SWIG_fail;
10435 {
10436 arg2 = &temp2;
10437 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10438 }
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10442
10443 wxPyEndAllowThreads(__tstate);
10444 if (PyErr_Occurred()) SWIG_fail;
10445 }
10446 {
10447 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10448 }
10449 return resultobj;
10450 fail:
10451 return NULL;
10452 }
10453
10454
10455 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10456 PyObject *obj;
10457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10458 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10459 Py_INCREF(obj);
10460 return Py_BuildValue((char *)"");
10461 }
10462 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj;
10464 wxString *arg1 = 0 ;
10465 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10466 int arg3 = (int) -1 ;
10467 wxImage *result;
10468 bool temp1 = false ;
10469 PyObject * obj0 = 0 ;
10470 PyObject * obj1 = 0 ;
10471 PyObject * obj2 = 0 ;
10472 char *kwnames[] = {
10473 (char *) "name",(char *) "type",(char *) "index", NULL
10474 };
10475
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10477 {
10478 arg1 = wxString_in_helper(obj0);
10479 if (arg1 == NULL) SWIG_fail;
10480 temp1 = true;
10481 }
10482 if (obj1) {
10483 {
10484 arg2 = (long)(SWIG_As_long(obj1));
10485 if (SWIG_arg_fail(2)) SWIG_fail;
10486 }
10487 }
10488 if (obj2) {
10489 {
10490 arg3 = (int)(SWIG_As_int(obj2));
10491 if (SWIG_arg_fail(3)) SWIG_fail;
10492 }
10493 }
10494 {
10495 PyThreadState* __tstate = wxPyBeginAllowThreads();
10496 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10497
10498 wxPyEndAllowThreads(__tstate);
10499 if (PyErr_Occurred()) SWIG_fail;
10500 }
10501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10502 {
10503 if (temp1)
10504 delete arg1;
10505 }
10506 return resultobj;
10507 fail:
10508 {
10509 if (temp1)
10510 delete arg1;
10511 }
10512 return NULL;
10513 }
10514
10515
10516 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj;
10518 wxImage *arg1 = (wxImage *) 0 ;
10519 PyObject * obj0 = 0 ;
10520 char *kwnames[] = {
10521 (char *) "self", NULL
10522 };
10523
10524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10526 if (SWIG_arg_fail(1)) SWIG_fail;
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 delete arg1;
10530
10531 wxPyEndAllowThreads(__tstate);
10532 if (PyErr_Occurred()) SWIG_fail;
10533 }
10534 Py_INCREF(Py_None); resultobj = Py_None;
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10542 PyObject *resultobj;
10543 wxString *arg1 = 0 ;
10544 wxString *arg2 = 0 ;
10545 int arg3 = (int) -1 ;
10546 wxImage *result;
10547 bool temp1 = false ;
10548 bool temp2 = false ;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 PyObject * obj2 = 0 ;
10552 char *kwnames[] = {
10553 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10554 };
10555
10556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10557 {
10558 arg1 = wxString_in_helper(obj0);
10559 if (arg1 == NULL) SWIG_fail;
10560 temp1 = true;
10561 }
10562 {
10563 arg2 = wxString_in_helper(obj1);
10564 if (arg2 == NULL) SWIG_fail;
10565 temp2 = true;
10566 }
10567 if (obj2) {
10568 {
10569 arg3 = (int)(SWIG_As_int(obj2));
10570 if (SWIG_arg_fail(3)) SWIG_fail;
10571 }
10572 }
10573 {
10574 PyThreadState* __tstate = wxPyBeginAllowThreads();
10575 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10576
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10581 {
10582 if (temp1)
10583 delete arg1;
10584 }
10585 {
10586 if (temp2)
10587 delete arg2;
10588 }
10589 return resultobj;
10590 fail:
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return NULL;
10600 }
10601
10602
10603 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10604 PyObject *resultobj;
10605 wxInputStream *arg1 = 0 ;
10606 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10607 int arg3 = (int) -1 ;
10608 wxImage *result;
10609 wxPyInputStream *temp1 ;
10610 bool created1 ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 PyObject * obj2 = 0 ;
10614 char *kwnames[] = {
10615 (char *) "stream",(char *) "type",(char *) "index", NULL
10616 };
10617
10618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10619 {
10620 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10621 arg1 = temp1->m_wxis;
10622 created1 = false;
10623 } else {
10624 PyErr_Clear(); // clear the failure of the wxPyConvert above
10625 arg1 = wxPyCBInputStream_create(obj0, false);
10626 if (arg1 == NULL) {
10627 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10628 SWIG_fail;
10629 }
10630 created1 = true;
10631 }
10632 }
10633 if (obj1) {
10634 {
10635 arg2 = (long)(SWIG_As_long(obj1));
10636 if (SWIG_arg_fail(2)) SWIG_fail;
10637 }
10638 }
10639 if (obj2) {
10640 {
10641 arg3 = (int)(SWIG_As_int(obj2));
10642 if (SWIG_arg_fail(3)) SWIG_fail;
10643 }
10644 }
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10648
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10653 {
10654 if (created1) delete arg1;
10655 }
10656 return resultobj;
10657 fail:
10658 {
10659 if (created1) delete arg1;
10660 }
10661 return NULL;
10662 }
10663
10664
10665 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10666 PyObject *resultobj;
10667 wxInputStream *arg1 = 0 ;
10668 wxString *arg2 = 0 ;
10669 int arg3 = (int) -1 ;
10670 wxImage *result;
10671 wxPyInputStream *temp1 ;
10672 bool created1 ;
10673 bool temp2 = false ;
10674 PyObject * obj0 = 0 ;
10675 PyObject * obj1 = 0 ;
10676 PyObject * obj2 = 0 ;
10677 char *kwnames[] = {
10678 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10679 };
10680
10681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10682 {
10683 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10684 arg1 = temp1->m_wxis;
10685 created1 = false;
10686 } else {
10687 PyErr_Clear(); // clear the failure of the wxPyConvert above
10688 arg1 = wxPyCBInputStream_create(obj0, false);
10689 if (arg1 == NULL) {
10690 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10691 SWIG_fail;
10692 }
10693 created1 = true;
10694 }
10695 }
10696 {
10697 arg2 = wxString_in_helper(obj1);
10698 if (arg2 == NULL) SWIG_fail;
10699 temp2 = true;
10700 }
10701 if (obj2) {
10702 {
10703 arg3 = (int)(SWIG_As_int(obj2));
10704 if (SWIG_arg_fail(3)) SWIG_fail;
10705 }
10706 }
10707 {
10708 PyThreadState* __tstate = wxPyBeginAllowThreads();
10709 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10710
10711 wxPyEndAllowThreads(__tstate);
10712 if (PyErr_Occurred()) SWIG_fail;
10713 }
10714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10715 {
10716 if (created1) delete arg1;
10717 }
10718 {
10719 if (temp2)
10720 delete arg2;
10721 }
10722 return resultobj;
10723 fail:
10724 {
10725 if (created1) delete arg1;
10726 }
10727 {
10728 if (temp2)
10729 delete arg2;
10730 }
10731 return NULL;
10732 }
10733
10734
10735 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj;
10737 int arg1 = (int) 0 ;
10738 int arg2 = (int) 0 ;
10739 bool arg3 = (bool) true ;
10740 wxImage *result;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 PyObject * obj2 = 0 ;
10744 char *kwnames[] = {
10745 (char *) "width",(char *) "height",(char *) "clear", NULL
10746 };
10747
10748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10749 if (obj0) {
10750 {
10751 arg1 = (int)(SWIG_As_int(obj0));
10752 if (SWIG_arg_fail(1)) SWIG_fail;
10753 }
10754 }
10755 if (obj1) {
10756 {
10757 arg2 = (int)(SWIG_As_int(obj1));
10758 if (SWIG_arg_fail(2)) SWIG_fail;
10759 }
10760 }
10761 if (obj2) {
10762 {
10763 arg3 = (bool)(SWIG_As_bool(obj2));
10764 if (SWIG_arg_fail(3)) SWIG_fail;
10765 }
10766 }
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10770
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10782 PyObject *resultobj;
10783 wxBitmap *arg1 = 0 ;
10784 wxImage *result;
10785 PyObject * obj0 = 0 ;
10786 char *kwnames[] = {
10787 (char *) "bitmap", NULL
10788 };
10789
10790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10791 {
10792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10793 if (SWIG_arg_fail(1)) SWIG_fail;
10794 if (arg1 == NULL) {
10795 SWIG_null_ref("wxBitmap");
10796 }
10797 if (SWIG_arg_fail(1)) SWIG_fail;
10798 }
10799 {
10800 if (!wxPyCheckForApp()) SWIG_fail;
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10803
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10815 PyObject *resultobj;
10816 int arg1 ;
10817 int arg2 ;
10818 buffer arg3 ;
10819 int arg4 ;
10820 wxImage *result;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 PyObject * obj2 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "width",(char *) "height",(char *) "data", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10829 {
10830 arg1 = (int)(SWIG_As_int(obj0));
10831 if (SWIG_arg_fail(1)) SWIG_fail;
10832 }
10833 {
10834 arg2 = (int)(SWIG_As_int(obj1));
10835 if (SWIG_arg_fail(2)) SWIG_fail;
10836 }
10837 {
10838 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10839 }
10840 {
10841 PyThreadState* __tstate = wxPyBeginAllowThreads();
10842 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10843
10844 wxPyEndAllowThreads(__tstate);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10848 return resultobj;
10849 fail:
10850 return NULL;
10851 }
10852
10853
10854 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10855 PyObject *resultobj;
10856 int arg1 ;
10857 int arg2 ;
10858 buffer arg3 ;
10859 int arg4 ;
10860 buffer arg5 ;
10861 int arg6 ;
10862 wxImage *result;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 PyObject * obj2 = 0 ;
10866 PyObject * obj3 = 0 ;
10867 char *kwnames[] = {
10868 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10869 };
10870
10871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10872 {
10873 arg1 = (int)(SWIG_As_int(obj0));
10874 if (SWIG_arg_fail(1)) SWIG_fail;
10875 }
10876 {
10877 arg2 = (int)(SWIG_As_int(obj1));
10878 if (SWIG_arg_fail(2)) SWIG_fail;
10879 }
10880 {
10881 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10882 }
10883 {
10884 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10885 }
10886 {
10887 PyThreadState* __tstate = wxPyBeginAllowThreads();
10888 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10889
10890 wxPyEndAllowThreads(__tstate);
10891 if (PyErr_Occurred()) SWIG_fail;
10892 }
10893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10901 PyObject *resultobj;
10902 wxImage *arg1 = (wxImage *) 0 ;
10903 int arg2 ;
10904 int arg3 ;
10905 PyObject * obj0 = 0 ;
10906 PyObject * obj1 = 0 ;
10907 PyObject * obj2 = 0 ;
10908 char *kwnames[] = {
10909 (char *) "self",(char *) "width",(char *) "height", NULL
10910 };
10911
10912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10914 if (SWIG_arg_fail(1)) SWIG_fail;
10915 {
10916 arg2 = (int)(SWIG_As_int(obj1));
10917 if (SWIG_arg_fail(2)) SWIG_fail;
10918 }
10919 {
10920 arg3 = (int)(SWIG_As_int(obj2));
10921 if (SWIG_arg_fail(3)) SWIG_fail;
10922 }
10923 {
10924 PyThreadState* __tstate = wxPyBeginAllowThreads();
10925 (arg1)->Create(arg2,arg3);
10926
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 Py_INCREF(Py_None); resultobj = Py_None;
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj;
10939 wxImage *arg1 = (wxImage *) 0 ;
10940 PyObject * obj0 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 {
10949 PyThreadState* __tstate = wxPyBeginAllowThreads();
10950 (arg1)->Destroy();
10951
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 Py_INCREF(Py_None); resultobj = Py_None;
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj;
10964 wxImage *arg1 = (wxImage *) 0 ;
10965 int arg2 ;
10966 int arg3 ;
10967 SwigValueWrapper<wxImage > result;
10968 PyObject * obj0 = 0 ;
10969 PyObject * obj1 = 0 ;
10970 PyObject * obj2 = 0 ;
10971 char *kwnames[] = {
10972 (char *) "self",(char *) "width",(char *) "height", NULL
10973 };
10974
10975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10977 if (SWIG_arg_fail(1)) SWIG_fail;
10978 {
10979 arg2 = (int)(SWIG_As_int(obj1));
10980 if (SWIG_arg_fail(2)) SWIG_fail;
10981 }
10982 {
10983 arg3 = (int)(SWIG_As_int(obj2));
10984 if (SWIG_arg_fail(3)) SWIG_fail;
10985 }
10986 {
10987 PyThreadState* __tstate = wxPyBeginAllowThreads();
10988 result = (arg1)->Scale(arg2,arg3);
10989
10990 wxPyEndAllowThreads(__tstate);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 wxImage * resultptr;
10995 resultptr = new wxImage((wxImage &)(result));
10996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10997 }
10998 return resultobj;
10999 fail:
11000 return NULL;
11001 }
11002
11003
11004 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11005 PyObject *resultobj;
11006 wxImage *arg1 = (wxImage *) 0 ;
11007 int arg2 ;
11008 int arg3 ;
11009 SwigValueWrapper<wxImage > result;
11010 PyObject * obj0 = 0 ;
11011 PyObject * obj1 = 0 ;
11012 PyObject * obj2 = 0 ;
11013 char *kwnames[] = {
11014 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11015 };
11016
11017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11019 if (SWIG_arg_fail(1)) SWIG_fail;
11020 {
11021 arg2 = (int)(SWIG_As_int(obj1));
11022 if (SWIG_arg_fail(2)) SWIG_fail;
11023 }
11024 {
11025 arg3 = (int)(SWIG_As_int(obj2));
11026 if (SWIG_arg_fail(3)) SWIG_fail;
11027 }
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11031
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 {
11036 wxImage * resultptr;
11037 resultptr = new wxImage((wxImage &)(result));
11038 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11039 }
11040 return resultobj;
11041 fail:
11042 return NULL;
11043 }
11044
11045
11046 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11047 PyObject *resultobj;
11048 wxImage *arg1 = (wxImage *) 0 ;
11049 int arg2 ;
11050 int arg3 ;
11051 wxImage *result;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 char *kwnames[] = {
11056 (char *) "self",(char *) "width",(char *) "height", NULL
11057 };
11058
11059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11061 if (SWIG_arg_fail(1)) SWIG_fail;
11062 {
11063 arg2 = (int)(SWIG_As_int(obj1));
11064 if (SWIG_arg_fail(2)) SWIG_fail;
11065 }
11066 {
11067 arg3 = (int)(SWIG_As_int(obj2));
11068 if (SWIG_arg_fail(3)) SWIG_fail;
11069 }
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 {
11073 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11074 result = (wxImage *) &_result_ref;
11075 }
11076
11077 wxPyEndAllowThreads(__tstate);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11081 return resultobj;
11082 fail:
11083 return NULL;
11084 }
11085
11086
11087 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11088 PyObject *resultobj;
11089 wxImage *arg1 = (wxImage *) 0 ;
11090 wxSize *arg2 = 0 ;
11091 wxPoint *arg3 = 0 ;
11092 int arg4 = (int) -1 ;
11093 int arg5 = (int) -1 ;
11094 int arg6 = (int) -1 ;
11095 wxImage *result;
11096 wxSize temp2 ;
11097 wxPoint temp3 ;
11098 PyObject * obj0 = 0 ;
11099 PyObject * obj1 = 0 ;
11100 PyObject * obj2 = 0 ;
11101 PyObject * obj3 = 0 ;
11102 PyObject * obj4 = 0 ;
11103 PyObject * obj5 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 arg2 = &temp2;
11113 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11114 }
11115 {
11116 arg3 = &temp3;
11117 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11118 }
11119 if (obj3) {
11120 {
11121 arg4 = (int)(SWIG_As_int(obj3));
11122 if (SWIG_arg_fail(4)) SWIG_fail;
11123 }
11124 }
11125 if (obj4) {
11126 {
11127 arg5 = (int)(SWIG_As_int(obj4));
11128 if (SWIG_arg_fail(5)) SWIG_fail;
11129 }
11130 }
11131 if (obj5) {
11132 {
11133 arg6 = (int)(SWIG_As_int(obj5));
11134 if (SWIG_arg_fail(6)) SWIG_fail;
11135 }
11136 }
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 {
11140 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11141 result = (wxImage *) &_result_ref;
11142 }
11143
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11148 return resultobj;
11149 fail:
11150 return NULL;
11151 }
11152
11153
11154 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj;
11156 wxImage *arg1 = (wxImage *) 0 ;
11157 int arg2 ;
11158 int arg3 ;
11159 unsigned char arg4 ;
11160 unsigned char arg5 ;
11161 unsigned char arg6 ;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 PyObject * obj3 = 0 ;
11166 PyObject * obj4 = 0 ;
11167 PyObject * obj5 = 0 ;
11168 char *kwnames[] = {
11169 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11170 };
11171
11172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11174 if (SWIG_arg_fail(1)) SWIG_fail;
11175 {
11176 arg2 = (int)(SWIG_As_int(obj1));
11177 if (SWIG_arg_fail(2)) SWIG_fail;
11178 }
11179 {
11180 arg3 = (int)(SWIG_As_int(obj2));
11181 if (SWIG_arg_fail(3)) SWIG_fail;
11182 }
11183 {
11184 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11185 if (SWIG_arg_fail(4)) SWIG_fail;
11186 }
11187 {
11188 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11189 if (SWIG_arg_fail(5)) SWIG_fail;
11190 }
11191 {
11192 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11193 if (SWIG_arg_fail(6)) SWIG_fail;
11194 }
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11198
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 Py_INCREF(Py_None); resultobj = Py_None;
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
11209 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 wxImage *arg1 = (wxImage *) 0 ;
11212 wxRect *arg2 = 0 ;
11213 unsigned char arg3 ;
11214 unsigned char arg4 ;
11215 unsigned char arg5 ;
11216 wxRect temp2 ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 PyObject * obj3 = 0 ;
11221 PyObject * obj4 = 0 ;
11222 char *kwnames[] = {
11223 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11224 };
11225
11226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11228 if (SWIG_arg_fail(1)) SWIG_fail;
11229 {
11230 arg2 = &temp2;
11231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11232 }
11233 {
11234 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11235 if (SWIG_arg_fail(3)) SWIG_fail;
11236 }
11237 {
11238 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11239 if (SWIG_arg_fail(4)) SWIG_fail;
11240 }
11241 {
11242 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11243 if (SWIG_arg_fail(5)) SWIG_fail;
11244 }
11245 {
11246 PyThreadState* __tstate = wxPyBeginAllowThreads();
11247 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11248
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 Py_INCREF(Py_None); resultobj = Py_None;
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj;
11261 wxImage *arg1 = (wxImage *) 0 ;
11262 int arg2 ;
11263 int arg3 ;
11264 unsigned char result;
11265 PyObject * obj0 = 0 ;
11266 PyObject * obj1 = 0 ;
11267 PyObject * obj2 = 0 ;
11268 char *kwnames[] = {
11269 (char *) "self",(char *) "x",(char *) "y", NULL
11270 };
11271
11272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11274 if (SWIG_arg_fail(1)) SWIG_fail;
11275 {
11276 arg2 = (int)(SWIG_As_int(obj1));
11277 if (SWIG_arg_fail(2)) SWIG_fail;
11278 }
11279 {
11280 arg3 = (int)(SWIG_As_int(obj2));
11281 if (SWIG_arg_fail(3)) SWIG_fail;
11282 }
11283 {
11284 PyThreadState* __tstate = wxPyBeginAllowThreads();
11285 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11286
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 {
11291 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11292 }
11293 return resultobj;
11294 fail:
11295 return NULL;
11296 }
11297
11298
11299 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj;
11301 wxImage *arg1 = (wxImage *) 0 ;
11302 int arg2 ;
11303 int arg3 ;
11304 unsigned char result;
11305 PyObject * obj0 = 0 ;
11306 PyObject * obj1 = 0 ;
11307 PyObject * obj2 = 0 ;
11308 char *kwnames[] = {
11309 (char *) "self",(char *) "x",(char *) "y", NULL
11310 };
11311
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 {
11316 arg2 = (int)(SWIG_As_int(obj1));
11317 if (SWIG_arg_fail(2)) SWIG_fail;
11318 }
11319 {
11320 arg3 = (int)(SWIG_As_int(obj2));
11321 if (SWIG_arg_fail(3)) SWIG_fail;
11322 }
11323 {
11324 PyThreadState* __tstate = wxPyBeginAllowThreads();
11325 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11326
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 {
11331 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11332 }
11333 return resultobj;
11334 fail:
11335 return NULL;
11336 }
11337
11338
11339 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11340 PyObject *resultobj;
11341 wxImage *arg1 = (wxImage *) 0 ;
11342 int arg2 ;
11343 int arg3 ;
11344 unsigned char result;
11345 PyObject * obj0 = 0 ;
11346 PyObject * obj1 = 0 ;
11347 PyObject * obj2 = 0 ;
11348 char *kwnames[] = {
11349 (char *) "self",(char *) "x",(char *) "y", NULL
11350 };
11351
11352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11354 if (SWIG_arg_fail(1)) SWIG_fail;
11355 {
11356 arg2 = (int)(SWIG_As_int(obj1));
11357 if (SWIG_arg_fail(2)) SWIG_fail;
11358 }
11359 {
11360 arg3 = (int)(SWIG_As_int(obj2));
11361 if (SWIG_arg_fail(3)) SWIG_fail;
11362 }
11363 {
11364 PyThreadState* __tstate = wxPyBeginAllowThreads();
11365 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11366
11367 wxPyEndAllowThreads(__tstate);
11368 if (PyErr_Occurred()) SWIG_fail;
11369 }
11370 {
11371 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11372 }
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj;
11381 wxImage *arg1 = (wxImage *) 0 ;
11382 int arg2 ;
11383 int arg3 ;
11384 unsigned char arg4 ;
11385 PyObject * obj0 = 0 ;
11386 PyObject * obj1 = 0 ;
11387 PyObject * obj2 = 0 ;
11388 PyObject * obj3 = 0 ;
11389 char *kwnames[] = {
11390 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11391 };
11392
11393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 {
11397 arg2 = (int)(SWIG_As_int(obj1));
11398 if (SWIG_arg_fail(2)) SWIG_fail;
11399 }
11400 {
11401 arg3 = (int)(SWIG_As_int(obj2));
11402 if (SWIG_arg_fail(3)) SWIG_fail;
11403 }
11404 {
11405 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11406 if (SWIG_arg_fail(4)) SWIG_fail;
11407 }
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 (arg1)->SetAlpha(arg2,arg3,arg4);
11411
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 Py_INCREF(Py_None); resultobj = Py_None;
11416 return resultobj;
11417 fail:
11418 return NULL;
11419 }
11420
11421
11422 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11423 PyObject *resultobj;
11424 wxImage *arg1 = (wxImage *) 0 ;
11425 int arg2 ;
11426 int arg3 ;
11427 unsigned char result;
11428 PyObject * obj0 = 0 ;
11429 PyObject * obj1 = 0 ;
11430 PyObject * obj2 = 0 ;
11431 char *kwnames[] = {
11432 (char *) "self",(char *) "x",(char *) "y", NULL
11433 };
11434
11435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 {
11439 arg2 = (int)(SWIG_As_int(obj1));
11440 if (SWIG_arg_fail(2)) SWIG_fail;
11441 }
11442 {
11443 arg3 = (int)(SWIG_As_int(obj2));
11444 if (SWIG_arg_fail(3)) SWIG_fail;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11449
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 {
11454 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11455 }
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 wxImage *arg1 = (wxImage *) 0 ;
11465 bool result;
11466 PyObject * obj0 = 0 ;
11467 char *kwnames[] = {
11468 (char *) "self", NULL
11469 };
11470
11471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11473 if (SWIG_arg_fail(1)) SWIG_fail;
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (bool)(arg1)->HasAlpha();
11477
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11483 }
11484 return resultobj;
11485 fail:
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj;
11492 wxImage *arg1 = (wxImage *) 0 ;
11493 PyObject * obj0 = 0 ;
11494 char *kwnames[] = {
11495 (char *) "self", NULL
11496 };
11497
11498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11500 if (SWIG_arg_fail(1)) SWIG_fail;
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 (arg1)->InitAlpha();
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 Py_INCREF(Py_None); resultobj = Py_None;
11509 return resultobj;
11510 fail:
11511 return NULL;
11512 }
11513
11514
11515 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj;
11517 wxImage *arg1 = (wxImage *) 0 ;
11518 int arg2 ;
11519 int arg3 ;
11520 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11521 bool result;
11522 PyObject * obj0 = 0 ;
11523 PyObject * obj1 = 0 ;
11524 PyObject * obj2 = 0 ;
11525 PyObject * obj3 = 0 ;
11526 char *kwnames[] = {
11527 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11528 };
11529
11530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 {
11534 arg2 = (int)(SWIG_As_int(obj1));
11535 if (SWIG_arg_fail(2)) SWIG_fail;
11536 }
11537 {
11538 arg3 = (int)(SWIG_As_int(obj2));
11539 if (SWIG_arg_fail(3)) SWIG_fail;
11540 }
11541 if (obj3) {
11542 {
11543 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11544 if (SWIG_arg_fail(4)) SWIG_fail;
11545 }
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11550
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxImage *arg1 = (wxImage *) 0 ;
11566 byte *arg2 = (byte *) 0 ;
11567 byte *arg3 = (byte *) 0 ;
11568 byte *arg4 = (byte *) 0 ;
11569 byte arg5 = (byte) 0 ;
11570 byte arg6 = (byte) 0 ;
11571 byte arg7 = (byte) 0 ;
11572 bool result;
11573 byte temp2 ;
11574 int res2 = 0 ;
11575 byte temp3 ;
11576 int res3 = 0 ;
11577 byte temp4 ;
11578 int res4 = 0 ;
11579 PyObject * obj0 = 0 ;
11580 PyObject * obj1 = 0 ;
11581 PyObject * obj2 = 0 ;
11582 PyObject * obj3 = 0 ;
11583 char *kwnames[] = {
11584 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11585 };
11586
11587 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11588 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11589 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11592 if (SWIG_arg_fail(1)) SWIG_fail;
11593 if (obj1) {
11594 {
11595 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11596 if (SWIG_arg_fail(5)) SWIG_fail;
11597 }
11598 }
11599 if (obj2) {
11600 {
11601 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11602 if (SWIG_arg_fail(6)) SWIG_fail;
11603 }
11604 }
11605 if (obj3) {
11606 {
11607 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11608 if (SWIG_arg_fail(7)) SWIG_fail;
11609 }
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11614
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 {
11619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11620 }
11621 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11622 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11623 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11624 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11625 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11626 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj;
11635 wxImage *arg1 = (wxImage *) 0 ;
11636 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11637 bool result;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 char *kwnames[] = {
11641 (char *) "self",(char *) "threshold", NULL
11642 };
11643
11644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11646 if (SWIG_arg_fail(1)) SWIG_fail;
11647 if (obj1) {
11648 {
11649 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11650 if (SWIG_arg_fail(2)) SWIG_fail;
11651 }
11652 }
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxImage *arg1 = (wxImage *) 0 ;
11672 unsigned char arg2 ;
11673 unsigned char arg3 ;
11674 unsigned char arg4 ;
11675 bool result;
11676 PyObject * obj0 = 0 ;
11677 PyObject * obj1 = 0 ;
11678 PyObject * obj2 = 0 ;
11679 PyObject * obj3 = 0 ;
11680 char *kwnames[] = {
11681 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11682 };
11683
11684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11686 if (SWIG_arg_fail(1)) SWIG_fail;
11687 {
11688 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11689 if (SWIG_arg_fail(2)) SWIG_fail;
11690 }
11691 {
11692 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11693 if (SWIG_arg_fail(3)) SWIG_fail;
11694 }
11695 {
11696 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11697 if (SWIG_arg_fail(4)) SWIG_fail;
11698 }
11699 {
11700 PyThreadState* __tstate = wxPyBeginAllowThreads();
11701 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11702
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11716 PyObject *resultobj;
11717 wxImage *arg1 = (wxImage *) 0 ;
11718 wxImage *arg2 = 0 ;
11719 byte arg3 ;
11720 byte arg4 ;
11721 byte arg5 ;
11722 bool result;
11723 PyObject * obj0 = 0 ;
11724 PyObject * obj1 = 0 ;
11725 PyObject * obj2 = 0 ;
11726 PyObject * obj3 = 0 ;
11727 PyObject * obj4 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11737 if (SWIG_arg_fail(2)) SWIG_fail;
11738 if (arg2 == NULL) {
11739 SWIG_null_ref("wxImage");
11740 }
11741 if (SWIG_arg_fail(2)) SWIG_fail;
11742 }
11743 {
11744 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11745 if (SWIG_arg_fail(3)) SWIG_fail;
11746 }
11747 {
11748 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11749 if (SWIG_arg_fail(4)) SWIG_fail;
11750 }
11751 {
11752 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11753 if (SWIG_arg_fail(5)) SWIG_fail;
11754 }
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11758
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 {
11763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11772 PyObject *resultobj;
11773 wxString *arg1 = 0 ;
11774 bool result;
11775 bool temp1 = false ;
11776 PyObject * obj0 = 0 ;
11777 char *kwnames[] = {
11778 (char *) "name", NULL
11779 };
11780
11781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11782 {
11783 arg1 = wxString_in_helper(obj0);
11784 if (arg1 == NULL) SWIG_fail;
11785 temp1 = true;
11786 }
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11790
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11796 }
11797 {
11798 if (temp1)
11799 delete arg1;
11800 }
11801 return resultobj;
11802 fail:
11803 {
11804 if (temp1)
11805 delete arg1;
11806 }
11807 return NULL;
11808 }
11809
11810
11811 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11812 PyObject *resultobj;
11813 wxString *arg1 = 0 ;
11814 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11815 int result;
11816 bool temp1 = false ;
11817 PyObject * obj0 = 0 ;
11818 PyObject * obj1 = 0 ;
11819 char *kwnames[] = {
11820 (char *) "name",(char *) "type", NULL
11821 };
11822
11823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11824 {
11825 arg1 = wxString_in_helper(obj0);
11826 if (arg1 == NULL) SWIG_fail;
11827 temp1 = true;
11828 }
11829 if (obj1) {
11830 {
11831 arg2 = (long)(SWIG_As_long(obj1));
11832 if (SWIG_arg_fail(2)) SWIG_fail;
11833 }
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = SWIG_From_int((int)(result));
11844 }
11845 {
11846 if (temp1)
11847 delete arg1;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (temp1)
11853 delete arg1;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxImage *arg1 = (wxImage *) 0 ;
11862 wxString *arg2 = 0 ;
11863 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11864 int arg4 = (int) -1 ;
11865 bool result;
11866 bool temp2 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 PyObject * obj2 = 0 ;
11870 PyObject * obj3 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 arg2 = wxString_in_helper(obj1);
11880 if (arg2 == NULL) SWIG_fail;
11881 temp2 = true;
11882 }
11883 if (obj2) {
11884 {
11885 arg3 = (long)(SWIG_As_long(obj2));
11886 if (SWIG_arg_fail(3)) SWIG_fail;
11887 }
11888 }
11889 if (obj3) {
11890 {
11891 arg4 = (int)(SWIG_As_int(obj3));
11892 if (SWIG_arg_fail(4)) SWIG_fail;
11893 }
11894 }
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11898
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 {
11903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11904 }
11905 {
11906 if (temp2)
11907 delete arg2;
11908 }
11909 return resultobj;
11910 fail:
11911 {
11912 if (temp2)
11913 delete arg2;
11914 }
11915 return NULL;
11916 }
11917
11918
11919 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11920 PyObject *resultobj;
11921 wxImage *arg1 = (wxImage *) 0 ;
11922 wxString *arg2 = 0 ;
11923 wxString *arg3 = 0 ;
11924 int arg4 = (int) -1 ;
11925 bool result;
11926 bool temp2 = false ;
11927 bool temp3 = false ;
11928 PyObject * obj0 = 0 ;
11929 PyObject * obj1 = 0 ;
11930 PyObject * obj2 = 0 ;
11931 PyObject * obj3 = 0 ;
11932 char *kwnames[] = {
11933 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11934 };
11935
11936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11938 if (SWIG_arg_fail(1)) SWIG_fail;
11939 {
11940 arg2 = wxString_in_helper(obj1);
11941 if (arg2 == NULL) SWIG_fail;
11942 temp2 = true;
11943 }
11944 {
11945 arg3 = wxString_in_helper(obj2);
11946 if (arg3 == NULL) SWIG_fail;
11947 temp3 = true;
11948 }
11949 if (obj3) {
11950 {
11951 arg4 = (int)(SWIG_As_int(obj3));
11952 if (SWIG_arg_fail(4)) SWIG_fail;
11953 }
11954 }
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11958
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11964 }
11965 {
11966 if (temp2)
11967 delete arg2;
11968 }
11969 {
11970 if (temp3)
11971 delete arg3;
11972 }
11973 return resultobj;
11974 fail:
11975 {
11976 if (temp2)
11977 delete arg2;
11978 }
11979 {
11980 if (temp3)
11981 delete arg3;
11982 }
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxImage *arg1 = (wxImage *) 0 ;
11990 wxString *arg2 = 0 ;
11991 int arg3 ;
11992 bool result;
11993 bool temp2 = false ;
11994 PyObject * obj0 = 0 ;
11995 PyObject * obj1 = 0 ;
11996 PyObject * obj2 = 0 ;
11997 char *kwnames[] = {
11998 (char *) "self",(char *) "name",(char *) "type", NULL
11999 };
12000
12001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12003 if (SWIG_arg_fail(1)) SWIG_fail;
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 arg3 = (int)(SWIG_As_int(obj2));
12011 if (SWIG_arg_fail(3)) SWIG_fail;
12012 }
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12016
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 {
12021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12022 }
12023 {
12024 if (temp2)
12025 delete arg2;
12026 }
12027 return resultobj;
12028 fail:
12029 {
12030 if (temp2)
12031 delete arg2;
12032 }
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxImage *arg1 = (wxImage *) 0 ;
12040 wxString *arg2 = 0 ;
12041 wxString *arg3 = 0 ;
12042 bool result;
12043 bool temp2 = false ;
12044 bool temp3 = false ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 PyObject * obj2 = 0 ;
12048 char *kwnames[] = {
12049 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12050 };
12051
12052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12054 if (SWIG_arg_fail(1)) SWIG_fail;
12055 {
12056 arg2 = wxString_in_helper(obj1);
12057 if (arg2 == NULL) SWIG_fail;
12058 temp2 = true;
12059 }
12060 {
12061 arg3 = wxString_in_helper(obj2);
12062 if (arg3 == NULL) SWIG_fail;
12063 temp3 = true;
12064 }
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12068
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 {
12073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12074 }
12075 {
12076 if (temp2)
12077 delete arg2;
12078 }
12079 {
12080 if (temp3)
12081 delete arg3;
12082 }
12083 return resultobj;
12084 fail:
12085 {
12086 if (temp2)
12087 delete arg2;
12088 }
12089 {
12090 if (temp3)
12091 delete arg3;
12092 }
12093 return NULL;
12094 }
12095
12096
12097 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12098 PyObject *resultobj;
12099 wxInputStream *arg1 = 0 ;
12100 bool result;
12101 wxPyInputStream *temp1 ;
12102 bool created1 ;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "stream", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12109 {
12110 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12111 arg1 = temp1->m_wxis;
12112 created1 = false;
12113 } else {
12114 PyErr_Clear(); // clear the failure of the wxPyConvert above
12115 arg1 = wxPyCBInputStream_create(obj0, false);
12116 if (arg1 == NULL) {
12117 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12118 SWIG_fail;
12119 }
12120 created1 = true;
12121 }
12122 }
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 result = (bool)wxImage::CanRead(*arg1);
12126
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 {
12131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12132 }
12133 {
12134 if (created1) delete arg1;
12135 }
12136 return resultobj;
12137 fail:
12138 {
12139 if (created1) delete arg1;
12140 }
12141 return NULL;
12142 }
12143
12144
12145 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12146 PyObject *resultobj;
12147 wxImage *arg1 = (wxImage *) 0 ;
12148 wxInputStream *arg2 = 0 ;
12149 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12150 int arg4 = (int) -1 ;
12151 bool result;
12152 wxPyInputStream *temp2 ;
12153 bool created2 ;
12154 PyObject * obj0 = 0 ;
12155 PyObject * obj1 = 0 ;
12156 PyObject * obj2 = 0 ;
12157 PyObject * obj3 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 {
12166 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12167 arg2 = temp2->m_wxis;
12168 created2 = false;
12169 } else {
12170 PyErr_Clear(); // clear the failure of the wxPyConvert above
12171 arg2 = wxPyCBInputStream_create(obj1, false);
12172 if (arg2 == NULL) {
12173 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12174 SWIG_fail;
12175 }
12176 created2 = true;
12177 }
12178 }
12179 if (obj2) {
12180 {
12181 arg3 = (long)(SWIG_As_long(obj2));
12182 if (SWIG_arg_fail(3)) SWIG_fail;
12183 }
12184 }
12185 if (obj3) {
12186 {
12187 arg4 = (int)(SWIG_As_int(obj3));
12188 if (SWIG_arg_fail(4)) SWIG_fail;
12189 }
12190 }
12191 {
12192 PyThreadState* __tstate = wxPyBeginAllowThreads();
12193 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12194
12195 wxPyEndAllowThreads(__tstate);
12196 if (PyErr_Occurred()) SWIG_fail;
12197 }
12198 {
12199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12200 }
12201 {
12202 if (created2) delete arg2;
12203 }
12204 return resultobj;
12205 fail:
12206 {
12207 if (created2) delete arg2;
12208 }
12209 return NULL;
12210 }
12211
12212
12213 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12214 PyObject *resultobj;
12215 wxImage *arg1 = (wxImage *) 0 ;
12216 wxInputStream *arg2 = 0 ;
12217 wxString *arg3 = 0 ;
12218 int arg4 = (int) -1 ;
12219 bool result;
12220 wxPyInputStream *temp2 ;
12221 bool created2 ;
12222 bool temp3 = false ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 PyObject * obj2 = 0 ;
12226 PyObject * obj3 = 0 ;
12227 char *kwnames[] = {
12228 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12229 };
12230
12231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12233 if (SWIG_arg_fail(1)) SWIG_fail;
12234 {
12235 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12236 arg2 = temp2->m_wxis;
12237 created2 = false;
12238 } else {
12239 PyErr_Clear(); // clear the failure of the wxPyConvert above
12240 arg2 = wxPyCBInputStream_create(obj1, false);
12241 if (arg2 == NULL) {
12242 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12243 SWIG_fail;
12244 }
12245 created2 = true;
12246 }
12247 }
12248 {
12249 arg3 = wxString_in_helper(obj2);
12250 if (arg3 == NULL) SWIG_fail;
12251 temp3 = true;
12252 }
12253 if (obj3) {
12254 {
12255 arg4 = (int)(SWIG_As_int(obj3));
12256 if (SWIG_arg_fail(4)) SWIG_fail;
12257 }
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 {
12267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12268 }
12269 {
12270 if (created2) delete arg2;
12271 }
12272 {
12273 if (temp3)
12274 delete arg3;
12275 }
12276 return resultobj;
12277 fail:
12278 {
12279 if (created2) delete arg2;
12280 }
12281 {
12282 if (temp3)
12283 delete arg3;
12284 }
12285 return NULL;
12286 }
12287
12288
12289 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj;
12291 wxImage *arg1 = (wxImage *) 0 ;
12292 bool result;
12293 PyObject * obj0 = 0 ;
12294 char *kwnames[] = {
12295 (char *) "self", NULL
12296 };
12297
12298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 {
12302 PyThreadState* __tstate = wxPyBeginAllowThreads();
12303 result = (bool)(arg1)->Ok();
12304
12305 wxPyEndAllowThreads(__tstate);
12306 if (PyErr_Occurred()) SWIG_fail;
12307 }
12308 {
12309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12310 }
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 int result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (int)(arg1)->GetWidth();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 resultobj = SWIG_From_int((int)(result));
12338 }
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12346 PyObject *resultobj;
12347 wxImage *arg1 = (wxImage *) 0 ;
12348 int result;
12349 PyObject * obj0 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 result = (int)(arg1)->GetHeight();
12360
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 {
12365 resultobj = SWIG_From_int((int)(result));
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj;
12375 wxImage *arg1 = (wxImage *) 0 ;
12376 wxSize result;
12377 PyObject * obj0 = 0 ;
12378 char *kwnames[] = {
12379 (char *) "self", NULL
12380 };
12381
12382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12384 if (SWIG_arg_fail(1)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = wxImage_GetSize(arg1);
12388
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 wxSize * resultptr;
12394 resultptr = new wxSize((wxSize &)(result));
12395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12396 }
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj;
12405 wxImage *arg1 = (wxImage *) 0 ;
12406 wxRect *arg2 = 0 ;
12407 SwigValueWrapper<wxImage > result;
12408 wxRect temp2 ;
12409 PyObject * obj0 = 0 ;
12410 PyObject * obj1 = 0 ;
12411 char *kwnames[] = {
12412 (char *) "self",(char *) "rect", NULL
12413 };
12414
12415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12417 if (SWIG_arg_fail(1)) SWIG_fail;
12418 {
12419 arg2 = &temp2;
12420 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12421 }
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12425
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 {
12430 wxImage * resultptr;
12431 resultptr = new wxImage((wxImage &)(result));
12432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12433 }
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12441 PyObject *resultobj;
12442 wxImage *arg1 = (wxImage *) 0 ;
12443 wxSize *arg2 = 0 ;
12444 wxPoint *arg3 = 0 ;
12445 int arg4 = (int) -1 ;
12446 int arg5 = (int) -1 ;
12447 int arg6 = (int) -1 ;
12448 SwigValueWrapper<wxImage > result;
12449 wxSize temp2 ;
12450 wxPoint temp3 ;
12451 PyObject * obj0 = 0 ;
12452 PyObject * obj1 = 0 ;
12453 PyObject * obj2 = 0 ;
12454 PyObject * obj3 = 0 ;
12455 PyObject * obj4 = 0 ;
12456 PyObject * obj5 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 arg2 = &temp2;
12466 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12467 }
12468 {
12469 arg3 = &temp3;
12470 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12471 }
12472 if (obj3) {
12473 {
12474 arg4 = (int)(SWIG_As_int(obj3));
12475 if (SWIG_arg_fail(4)) SWIG_fail;
12476 }
12477 }
12478 if (obj4) {
12479 {
12480 arg5 = (int)(SWIG_As_int(obj4));
12481 if (SWIG_arg_fail(5)) SWIG_fail;
12482 }
12483 }
12484 if (obj5) {
12485 {
12486 arg6 = (int)(SWIG_As_int(obj5));
12487 if (SWIG_arg_fail(6)) SWIG_fail;
12488 }
12489 }
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 wxImage * resultptr;
12499 resultptr = new wxImage((wxImage &)(result));
12500 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj;
12510 wxImage *arg1 = (wxImage *) 0 ;
12511 SwigValueWrapper<wxImage > result;
12512 PyObject * obj0 = 0 ;
12513 char *kwnames[] = {
12514 (char *) "self", NULL
12515 };
12516
12517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12519 if (SWIG_arg_fail(1)) SWIG_fail;
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 result = (arg1)->Copy();
12523
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 {
12528 wxImage * resultptr;
12529 resultptr = new wxImage((wxImage &)(result));
12530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12531 }
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj;
12540 wxImage *arg1 = (wxImage *) 0 ;
12541 wxImage *arg2 = 0 ;
12542 int arg3 ;
12543 int arg4 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 PyObject * obj2 = 0 ;
12547 PyObject * obj3 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12554 if (SWIG_arg_fail(1)) SWIG_fail;
12555 {
12556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(2)) SWIG_fail;
12558 if (arg2 == NULL) {
12559 SWIG_null_ref("wxImage");
12560 }
12561 if (SWIG_arg_fail(2)) SWIG_fail;
12562 }
12563 {
12564 arg3 = (int)(SWIG_As_int(obj2));
12565 if (SWIG_arg_fail(3)) SWIG_fail;
12566 }
12567 {
12568 arg4 = (int)(SWIG_As_int(obj3));
12569 if (SWIG_arg_fail(4)) SWIG_fail;
12570 }
12571 {
12572 PyThreadState* __tstate = wxPyBeginAllowThreads();
12573 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12574
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 Py_INCREF(Py_None); resultobj = Py_None;
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj;
12587 wxImage *arg1 = (wxImage *) 0 ;
12588 PyObject *result;
12589 PyObject * obj0 = 0 ;
12590 char *kwnames[] = {
12591 (char *) "self", NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12596 if (SWIG_arg_fail(1)) SWIG_fail;
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 result = (PyObject *)wxImage_GetData(arg1);
12600
12601 wxPyEndAllowThreads(__tstate);
12602 if (PyErr_Occurred()) SWIG_fail;
12603 }
12604 resultobj = result;
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12612 PyObject *resultobj;
12613 wxImage *arg1 = (wxImage *) 0 ;
12614 buffer arg2 ;
12615 int arg3 ;
12616 PyObject * obj0 = 0 ;
12617 PyObject * obj1 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self",(char *) "data", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12627 }
12628 {
12629 PyThreadState* __tstate = wxPyBeginAllowThreads();
12630 wxImage_SetData(arg1,arg2,arg3);
12631
12632 wxPyEndAllowThreads(__tstate);
12633 if (PyErr_Occurred()) SWIG_fail;
12634 }
12635 Py_INCREF(Py_None); resultobj = Py_None;
12636 return resultobj;
12637 fail:
12638 return NULL;
12639 }
12640
12641
12642 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12643 PyObject *resultobj;
12644 wxImage *arg1 = (wxImage *) 0 ;
12645 PyObject *result;
12646 PyObject * obj0 = 0 ;
12647 char *kwnames[] = {
12648 (char *) "self", NULL
12649 };
12650
12651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12653 if (SWIG_arg_fail(1)) SWIG_fail;
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12657
12658 wxPyEndAllowThreads(__tstate);
12659 if (PyErr_Occurred()) SWIG_fail;
12660 }
12661 resultobj = result;
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12669 PyObject *resultobj;
12670 wxImage *arg1 = (wxImage *) 0 ;
12671 buffer arg2 ;
12672 int arg3 ;
12673 PyObject * obj0 = 0 ;
12674 PyObject * obj1 = 0 ;
12675 char *kwnames[] = {
12676 (char *) "self",(char *) "data", NULL
12677 };
12678
12679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12681 if (SWIG_arg_fail(1)) SWIG_fail;
12682 {
12683 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12684 }
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 wxImage_SetDataBuffer(arg1,arg2,arg3);
12688
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 Py_INCREF(Py_None); resultobj = Py_None;
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj;
12701 wxImage *arg1 = (wxImage *) 0 ;
12702 PyObject *result;
12703 PyObject * obj0 = 0 ;
12704 char *kwnames[] = {
12705 (char *) "self", NULL
12706 };
12707
12708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12710 if (SWIG_arg_fail(1)) SWIG_fail;
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 result = (PyObject *)wxImage_GetAlphaData(arg1);
12714
12715 wxPyEndAllowThreads(__tstate);
12716 if (PyErr_Occurred()) SWIG_fail;
12717 }
12718 resultobj = result;
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12726 PyObject *resultobj;
12727 wxImage *arg1 = (wxImage *) 0 ;
12728 buffer arg2 ;
12729 int arg3 ;
12730 PyObject * obj0 = 0 ;
12731 PyObject * obj1 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self",(char *) "alpha", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12741 }
12742 {
12743 PyThreadState* __tstate = wxPyBeginAllowThreads();
12744 wxImage_SetAlphaData(arg1,arg2,arg3);
12745
12746 wxPyEndAllowThreads(__tstate);
12747 if (PyErr_Occurred()) SWIG_fail;
12748 }
12749 Py_INCREF(Py_None); resultobj = Py_None;
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12757 PyObject *resultobj;
12758 wxImage *arg1 = (wxImage *) 0 ;
12759 PyObject *result;
12760 PyObject * obj0 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12771
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 resultobj = result;
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12783 PyObject *resultobj;
12784 wxImage *arg1 = (wxImage *) 0 ;
12785 buffer arg2 ;
12786 int arg3 ;
12787 PyObject * obj0 = 0 ;
12788 PyObject * obj1 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self",(char *) "alpha", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 Py_INCREF(Py_None); resultobj = Py_None;
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 unsigned char arg2 ;
12817 unsigned char arg3 ;
12818 unsigned char arg4 ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 PyObject * obj2 = 0 ;
12822 PyObject * obj3 = 0 ;
12823 char *kwnames[] = {
12824 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12825 };
12826
12827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12829 if (SWIG_arg_fail(1)) SWIG_fail;
12830 {
12831 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12832 if (SWIG_arg_fail(2)) SWIG_fail;
12833 }
12834 {
12835 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12836 if (SWIG_arg_fail(3)) SWIG_fail;
12837 }
12838 {
12839 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12840 if (SWIG_arg_fail(4)) SWIG_fail;
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 (arg1)->SetMaskColour(arg2,arg3,arg4);
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 Py_INCREF(Py_None); resultobj = Py_None;
12850 return resultobj;
12851 fail:
12852 return NULL;
12853 }
12854
12855
12856 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12857 PyObject *resultobj;
12858 wxImage *arg1 = (wxImage *) 0 ;
12859 unsigned char *arg2 = (unsigned char *) 0 ;
12860 unsigned char *arg3 = (unsigned char *) 0 ;
12861 unsigned char *arg4 = (unsigned char *) 0 ;
12862 unsigned char temp2 ;
12863 int res2 = 0 ;
12864 unsigned char temp3 ;
12865 int res3 = 0 ;
12866 unsigned char temp4 ;
12867 int res4 = 0 ;
12868 PyObject * obj0 = 0 ;
12869 char *kwnames[] = {
12870 (char *) "self", NULL
12871 };
12872
12873 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12874 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12875 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12878 if (SWIG_arg_fail(1)) SWIG_fail;
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12882
12883 wxPyEndAllowThreads(__tstate);
12884 if (PyErr_Occurred()) SWIG_fail;
12885 }
12886 Py_INCREF(Py_None); resultobj = Py_None;
12887 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12888 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12889 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12890 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12891 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12892 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_Image_GetMaskRed(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_GetMaskRed",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)->GetMaskRed();
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_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxImage *arg1 = (wxImage *) 0 ;
12930 unsigned char result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (unsigned char)(arg1)->GetMaskGreen();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxImage *arg1 = (wxImage *) 0 ;
12958 unsigned char result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (unsigned char)(arg1)->GetMaskBlue();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxImage *arg1 = (wxImage *) 0 ;
12986 bool arg2 = (bool) true ;
12987 PyObject * obj0 = 0 ;
12988 PyObject * obj1 = 0 ;
12989 char *kwnames[] = {
12990 (char *) "self",(char *) "mask", NULL
12991 };
12992
12993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12995 if (SWIG_arg_fail(1)) SWIG_fail;
12996 if (obj1) {
12997 {
12998 arg2 = (bool)(SWIG_As_bool(obj1));
12999 if (SWIG_arg_fail(2)) SWIG_fail;
13000 }
13001 }
13002 {
13003 PyThreadState* __tstate = wxPyBeginAllowThreads();
13004 (arg1)->SetMask(arg2);
13005
13006 wxPyEndAllowThreads(__tstate);
13007 if (PyErr_Occurred()) SWIG_fail;
13008 }
13009 Py_INCREF(Py_None); resultobj = Py_None;
13010 return resultobj;
13011 fail:
13012 return NULL;
13013 }
13014
13015
13016 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13017 PyObject *resultobj;
13018 wxImage *arg1 = (wxImage *) 0 ;
13019 bool result;
13020 PyObject * obj0 = 0 ;
13021 char *kwnames[] = {
13022 (char *) "self", NULL
13023 };
13024
13025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13027 if (SWIG_arg_fail(1)) SWIG_fail;
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 result = (bool)(arg1)->HasMask();
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 {
13036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13037 }
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13045 PyObject *resultobj;
13046 wxImage *arg1 = (wxImage *) 0 ;
13047 double arg2 ;
13048 wxPoint *arg3 = 0 ;
13049 bool arg4 = (bool) true ;
13050 wxPoint *arg5 = (wxPoint *) NULL ;
13051 SwigValueWrapper<wxImage > result;
13052 wxPoint temp3 ;
13053 PyObject * obj0 = 0 ;
13054 PyObject * obj1 = 0 ;
13055 PyObject * obj2 = 0 ;
13056 PyObject * obj3 = 0 ;
13057 PyObject * obj4 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 {
13066 arg2 = (double)(SWIG_As_double(obj1));
13067 if (SWIG_arg_fail(2)) SWIG_fail;
13068 }
13069 {
13070 arg3 = &temp3;
13071 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13072 }
13073 if (obj3) {
13074 {
13075 arg4 = (bool)(SWIG_As_bool(obj3));
13076 if (SWIG_arg_fail(4)) SWIG_fail;
13077 }
13078 }
13079 if (obj4) {
13080 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(5)) SWIG_fail;
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 {
13091 wxImage * resultptr;
13092 resultptr = new wxImage((wxImage &)(result));
13093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxImage *arg1 = (wxImage *) 0 ;
13104 bool arg2 = (bool) true ;
13105 SwigValueWrapper<wxImage > result;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self",(char *) "clockwise", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 if (obj1) {
13116 {
13117 arg2 = (bool)(SWIG_As_bool(obj1));
13118 if (SWIG_arg_fail(2)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (arg1)->Rotate90(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 wxImage * resultptr;
13130 resultptr = new wxImage((wxImage &)(result));
13131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 bool arg2 = (bool) true ;
13143 SwigValueWrapper<wxImage > result;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self",(char *) "horizontally", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 if (obj1) {
13154 {
13155 arg2 = (bool)(SWIG_As_bool(obj1));
13156 if (SWIG_arg_fail(2)) SWIG_fail;
13157 }
13158 }
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 result = (arg1)->Mirror(arg2);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 {
13167 wxImage * resultptr;
13168 resultptr = new wxImage((wxImage &)(result));
13169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13170 }
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxImage *arg1 = (wxImage *) 0 ;
13180 unsigned char arg2 ;
13181 unsigned char arg3 ;
13182 unsigned char arg4 ;
13183 unsigned char arg5 ;
13184 unsigned char arg6 ;
13185 unsigned char arg7 ;
13186 PyObject * obj0 = 0 ;
13187 PyObject * obj1 = 0 ;
13188 PyObject * obj2 = 0 ;
13189 PyObject * obj3 = 0 ;
13190 PyObject * obj4 = 0 ;
13191 PyObject * obj5 = 0 ;
13192 PyObject * obj6 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13214 if (SWIG_arg_fail(5)) SWIG_fail;
13215 }
13216 {
13217 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13218 if (SWIG_arg_fail(6)) SWIG_fail;
13219 }
13220 {
13221 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13222 if (SWIG_arg_fail(7)) SWIG_fail;
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 Py_INCREF(Py_None); resultobj = Py_None;
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj;
13240 wxImage *arg1 = (wxImage *) 0 ;
13241 unsigned char arg2 ;
13242 unsigned char arg3 ;
13243 unsigned char arg4 ;
13244 SwigValueWrapper<wxImage > result;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 PyObject * obj3 = 0 ;
13249 char *kwnames[] = {
13250 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13251 };
13252
13253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13255 if (SWIG_arg_fail(1)) SWIG_fail;
13256 {
13257 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 {
13261 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13262 if (SWIG_arg_fail(3)) SWIG_fail;
13263 }
13264 {
13265 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13266 if (SWIG_arg_fail(4)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 {
13276 wxImage * resultptr;
13277 resultptr = new wxImage((wxImage &)(result));
13278 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13279 }
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj;
13288 wxImage *arg1 = (wxImage *) 0 ;
13289 wxString *arg2 = 0 ;
13290 wxString *arg3 = 0 ;
13291 bool temp2 = false ;
13292 bool temp3 = 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_SetOption",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 = wxString_in_helper(obj2);
13310 if (arg3 == NULL) SWIG_fail;
13311 temp3 = true;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 Py_INCREF(Py_None); resultobj = Py_None;
13321 {
13322 if (temp2)
13323 delete arg2;
13324 }
13325 {
13326 if (temp3)
13327 delete arg3;
13328 }
13329 return resultobj;
13330 fail:
13331 {
13332 if (temp2)
13333 delete arg2;
13334 }
13335 {
13336 if (temp3)
13337 delete arg3;
13338 }
13339 return NULL;
13340 }
13341
13342
13343 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj;
13345 wxImage *arg1 = (wxImage *) 0 ;
13346 wxString *arg2 = 0 ;
13347 int arg3 ;
13348 bool temp2 = false ;
13349 PyObject * obj0 = 0 ;
13350 PyObject * obj1 = 0 ;
13351 PyObject * obj2 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self",(char *) "name",(char *) "value", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 {
13360 arg2 = wxString_in_helper(obj1);
13361 if (arg2 == NULL) SWIG_fail;
13362 temp2 = true;
13363 }
13364 {
13365 arg3 = (int)(SWIG_As_int(obj2));
13366 if (SWIG_arg_fail(3)) SWIG_fail;
13367 }
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 (arg1)->SetOption((wxString const &)*arg2,arg3);
13371
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 Py_INCREF(Py_None); resultobj = Py_None;
13376 {
13377 if (temp2)
13378 delete arg2;
13379 }
13380 return resultobj;
13381 fail:
13382 {
13383 if (temp2)
13384 delete arg2;
13385 }
13386 return NULL;
13387 }
13388
13389
13390 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj;
13392 wxImage *arg1 = (wxImage *) 0 ;
13393 wxString *arg2 = 0 ;
13394 wxString result;
13395 bool temp2 = false ;
13396 PyObject * obj0 = 0 ;
13397 PyObject * obj1 = 0 ;
13398 char *kwnames[] = {
13399 (char *) "self",(char *) "name", NULL
13400 };
13401
13402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13404 if (SWIG_arg_fail(1)) SWIG_fail;
13405 {
13406 arg2 = wxString_in_helper(obj1);
13407 if (arg2 == NULL) SWIG_fail;
13408 temp2 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 {
13418 #if wxUSE_UNICODE
13419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13420 #else
13421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13422 #endif
13423 }
13424 {
13425 if (temp2)
13426 delete arg2;
13427 }
13428 return resultobj;
13429 fail:
13430 {
13431 if (temp2)
13432 delete arg2;
13433 }
13434 return NULL;
13435 }
13436
13437
13438 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj;
13440 wxImage *arg1 = (wxImage *) 0 ;
13441 wxString *arg2 = 0 ;
13442 int result;
13443 bool temp2 = false ;
13444 PyObject * obj0 = 0 ;
13445 PyObject * obj1 = 0 ;
13446 char *kwnames[] = {
13447 (char *) "self",(char *) "name", NULL
13448 };
13449
13450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13452 if (SWIG_arg_fail(1)) SWIG_fail;
13453 {
13454 arg2 = wxString_in_helper(obj1);
13455 if (arg2 == NULL) SWIG_fail;
13456 temp2 = true;
13457 }
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13461
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 {
13466 resultobj = SWIG_From_int((int)(result));
13467 }
13468 {
13469 if (temp2)
13470 delete arg2;
13471 }
13472 return resultobj;
13473 fail:
13474 {
13475 if (temp2)
13476 delete arg2;
13477 }
13478 return NULL;
13479 }
13480
13481
13482 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj;
13484 wxImage *arg1 = (wxImage *) 0 ;
13485 wxString *arg2 = 0 ;
13486 bool result;
13487 bool temp2 = false ;
13488 PyObject * obj0 = 0 ;
13489 PyObject * obj1 = 0 ;
13490 char *kwnames[] = {
13491 (char *) "self",(char *) "name", NULL
13492 };
13493
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13496 if (SWIG_arg_fail(1)) SWIG_fail;
13497 {
13498 arg2 = wxString_in_helper(obj1);
13499 if (arg2 == NULL) SWIG_fail;
13500 temp2 = true;
13501 }
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13505
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 {
13510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13511 }
13512 {
13513 if (temp2)
13514 delete arg2;
13515 }
13516 return resultobj;
13517 fail:
13518 {
13519 if (temp2)
13520 delete arg2;
13521 }
13522 return NULL;
13523 }
13524
13525
13526 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj;
13528 wxImage *arg1 = (wxImage *) 0 ;
13529 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13530 unsigned long result;
13531 PyObject * obj0 = 0 ;
13532 PyObject * obj1 = 0 ;
13533 char *kwnames[] = {
13534 (char *) "self",(char *) "stopafter", NULL
13535 };
13536
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13539 if (SWIG_arg_fail(1)) SWIG_fail;
13540 if (obj1) {
13541 {
13542 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13543 if (SWIG_arg_fail(2)) SWIG_fail;
13544 }
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (unsigned long)(arg1)->CountColours(arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13555 }
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxImage *arg1 = (wxImage *) 0 ;
13565 wxImageHistogram *arg2 = 0 ;
13566 unsigned long result;
13567 PyObject * obj0 = 0 ;
13568 PyObject * obj1 = 0 ;
13569 char *kwnames[] = {
13570 (char *) "self",(char *) "h", NULL
13571 };
13572
13573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13575 if (SWIG_arg_fail(1)) SWIG_fail;
13576 {
13577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13578 if (SWIG_arg_fail(2)) SWIG_fail;
13579 if (arg2 == NULL) {
13580 SWIG_null_ref("wxImageHistogram");
13581 }
13582 if (SWIG_arg_fail(2)) SWIG_fail;
13583 }
13584 {
13585 PyThreadState* __tstate = wxPyBeginAllowThreads();
13586 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13587
13588 wxPyEndAllowThreads(__tstate);
13589 if (PyErr_Occurred()) SWIG_fail;
13590 }
13591 {
13592 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13593 }
13594 return resultobj;
13595 fail:
13596 return NULL;
13597 }
13598
13599
13600 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13601 PyObject *resultobj;
13602 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13603 PyObject * obj0 = 0 ;
13604 char *kwnames[] = {
13605 (char *) "handler", NULL
13606 };
13607
13608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13610 if (SWIG_arg_fail(1)) SWIG_fail;
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 wxImage::AddHandler(arg1);
13614
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 Py_INCREF(Py_None); resultobj = Py_None;
13619 return resultobj;
13620 fail:
13621 return NULL;
13622 }
13623
13624
13625 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj;
13627 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13628 PyObject * obj0 = 0 ;
13629 char *kwnames[] = {
13630 (char *) "handler", NULL
13631 };
13632
13633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13635 if (SWIG_arg_fail(1)) SWIG_fail;
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 wxImage::InsertHandler(arg1);
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 Py_INCREF(Py_None); resultobj = Py_None;
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj;
13652 wxString *arg1 = 0 ;
13653 bool result;
13654 bool temp1 = false ;
13655 PyObject * obj0 = 0 ;
13656 char *kwnames[] = {
13657 (char *) "name", NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13661 {
13662 arg1 = wxString_in_helper(obj0);
13663 if (arg1 == NULL) SWIG_fail;
13664 temp1 = true;
13665 }
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13669
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 {
13674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13675 }
13676 {
13677 if (temp1)
13678 delete arg1;
13679 }
13680 return resultobj;
13681 fail:
13682 {
13683 if (temp1)
13684 delete arg1;
13685 }
13686 return NULL;
13687 }
13688
13689
13690 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13691 PyObject *resultobj;
13692 wxString result;
13693 char *kwnames[] = {
13694 NULL
13695 };
13696
13697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 result = wxImage::GetImageExtWildcard();
13701
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 #if wxUSE_UNICODE
13707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13708 #else
13709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13710 #endif
13711 }
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxImage *arg1 = (wxImage *) 0 ;
13721 int arg2 = (int) -1 ;
13722 wxBitmap result;
13723 PyObject * obj0 = 0 ;
13724 PyObject * obj1 = 0 ;
13725 char *kwnames[] = {
13726 (char *) "self",(char *) "depth", NULL
13727 };
13728
13729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13731 if (SWIG_arg_fail(1)) SWIG_fail;
13732 if (obj1) {
13733 {
13734 arg2 = (int)(SWIG_As_int(obj1));
13735 if (SWIG_arg_fail(2)) SWIG_fail;
13736 }
13737 }
13738 {
13739 if (!wxPyCheckForApp()) SWIG_fail;
13740 PyThreadState* __tstate = wxPyBeginAllowThreads();
13741 result = wxImage_ConvertToBitmap(arg1,arg2);
13742
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 {
13747 wxBitmap * resultptr;
13748 resultptr = new wxBitmap((wxBitmap &)(result));
13749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13750 }
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj;
13759 wxImage *arg1 = (wxImage *) 0 ;
13760 unsigned char arg2 ;
13761 unsigned char arg3 ;
13762 unsigned char arg4 ;
13763 wxBitmap result;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 PyObject * obj2 = 0 ;
13767 PyObject * obj3 = 0 ;
13768 char *kwnames[] = {
13769 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13770 };
13771
13772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13774 if (SWIG_arg_fail(1)) SWIG_fail;
13775 {
13776 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13777 if (SWIG_arg_fail(2)) SWIG_fail;
13778 }
13779 {
13780 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13781 if (SWIG_arg_fail(3)) SWIG_fail;
13782 }
13783 {
13784 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13785 if (SWIG_arg_fail(4)) SWIG_fail;
13786 }
13787 {
13788 if (!wxPyCheckForApp()) SWIG_fail;
13789 PyThreadState* __tstate = wxPyBeginAllowThreads();
13790 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13791
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 {
13796 wxBitmap * resultptr;
13797 resultptr = new wxBitmap((wxBitmap &)(result));
13798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13799 }
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13807 PyObject *obj;
13808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13809 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13810 Py_INCREF(obj);
13811 return Py_BuildValue((char *)"");
13812 }
13813 static int _wrap_NullImage_set(PyObject *) {
13814 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13815 return 1;
13816 }
13817
13818
13819 static PyObject *_wrap_NullImage_get(void) {
13820 PyObject *pyobj;
13821
13822 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13823 return pyobj;
13824 }
13825
13826
13827 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13828 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13829 return 1;
13830 }
13831
13832
13833 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13834 PyObject *pyobj;
13835
13836 {
13837 #if wxUSE_UNICODE
13838 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13839 #else
13840 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13841 #endif
13842 }
13843 return pyobj;
13844 }
13845
13846
13847 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13848 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13849 return 1;
13850 }
13851
13852
13853 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13854 PyObject *pyobj;
13855
13856 {
13857 #if wxUSE_UNICODE
13858 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13859 #else
13860 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13861 #endif
13862 }
13863 return pyobj;
13864 }
13865
13866
13867 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13868 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13869 return 1;
13870 }
13871
13872
13873 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13874 PyObject *pyobj;
13875
13876 {
13877 #if wxUSE_UNICODE
13878 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13879 #else
13880 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13881 #endif
13882 }
13883 return pyobj;
13884 }
13885
13886
13887 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13888 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13889 return 1;
13890 }
13891
13892
13893 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13894 PyObject *pyobj;
13895
13896 {
13897 #if wxUSE_UNICODE
13898 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13899 #else
13900 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13901 #endif
13902 }
13903 return pyobj;
13904 }
13905
13906
13907 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13908 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13909 return 1;
13910 }
13911
13912
13913 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13914 PyObject *pyobj;
13915
13916 {
13917 #if wxUSE_UNICODE
13918 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13919 #else
13920 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13921 #endif
13922 }
13923 return pyobj;
13924 }
13925
13926
13927 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13928 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13929 return 1;
13930 }
13931
13932
13933 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13934 PyObject *pyobj;
13935
13936 {
13937 #if wxUSE_UNICODE
13938 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13939 #else
13940 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13941 #endif
13942 }
13943 return pyobj;
13944 }
13945
13946
13947 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13948 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13949 return 1;
13950 }
13951
13952
13953 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13954 PyObject *pyobj;
13955
13956 {
13957 #if wxUSE_UNICODE
13958 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13959 #else
13960 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13961 #endif
13962 }
13963 return pyobj;
13964 }
13965
13966
13967 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13968 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13969 return 1;
13970 }
13971
13972
13973 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13974 PyObject *pyobj;
13975
13976 {
13977 #if wxUSE_UNICODE
13978 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13979 #else
13980 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13981 #endif
13982 }
13983 return pyobj;
13984 }
13985
13986
13987 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13988 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13989 return 1;
13990 }
13991
13992
13993 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13994 PyObject *pyobj;
13995
13996 {
13997 #if wxUSE_UNICODE
13998 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13999 #else
14000 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14001 #endif
14002 }
14003 return pyobj;
14004 }
14005
14006
14007 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14008 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14009 return 1;
14010 }
14011
14012
14013 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14014 PyObject *pyobj;
14015
14016 {
14017 #if wxUSE_UNICODE
14018 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14019 #else
14020 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14021 #endif
14022 }
14023 return pyobj;
14024 }
14025
14026
14027 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14028 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14029 return 1;
14030 }
14031
14032
14033 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14034 PyObject *pyobj;
14035
14036 {
14037 #if wxUSE_UNICODE
14038 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14039 #else
14040 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14041 #endif
14042 }
14043 return pyobj;
14044 }
14045
14046
14047 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14048 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14049 return 1;
14050 }
14051
14052
14053 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14054 PyObject *pyobj;
14055
14056 {
14057 #if wxUSE_UNICODE
14058 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14059 #else
14060 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14061 #endif
14062 }
14063 return pyobj;
14064 }
14065
14066
14067 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14068 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14069 return 1;
14070 }
14071
14072
14073 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14074 PyObject *pyobj;
14075
14076 {
14077 #if wxUSE_UNICODE
14078 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14079 #else
14080 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14081 #endif
14082 }
14083 return pyobj;
14084 }
14085
14086
14087 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14088 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14089 return 1;
14090 }
14091
14092
14093 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14094 PyObject *pyobj;
14095
14096 {
14097 #if wxUSE_UNICODE
14098 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14099 #else
14100 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14101 #endif
14102 }
14103 return pyobj;
14104 }
14105
14106
14107 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14108 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14109 return 1;
14110 }
14111
14112
14113 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14114 PyObject *pyobj;
14115
14116 {
14117 #if wxUSE_UNICODE
14118 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14119 #else
14120 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14121 #endif
14122 }
14123 return pyobj;
14124 }
14125
14126
14127 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj;
14129 wxBMPHandler *result;
14130 char *kwnames[] = {
14131 NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (wxBMPHandler *)new wxBMPHandler();
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14150 PyObject *obj;
14151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14152 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14153 Py_INCREF(obj);
14154 return Py_BuildValue((char *)"");
14155 }
14156 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj;
14158 wxICOHandler *result;
14159 char *kwnames[] = {
14160 NULL
14161 };
14162
14163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (wxICOHandler *)new wxICOHandler();
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14172 return resultobj;
14173 fail:
14174 return NULL;
14175 }
14176
14177
14178 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14179 PyObject *obj;
14180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14181 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14182 Py_INCREF(obj);
14183 return Py_BuildValue((char *)"");
14184 }
14185 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxCURHandler *result;
14188 char *kwnames[] = {
14189 NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 result = (wxCURHandler *)new wxCURHandler();
14196
14197 wxPyEndAllowThreads(__tstate);
14198 if (PyErr_Occurred()) SWIG_fail;
14199 }
14200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14208 PyObject *obj;
14209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14210 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14211 Py_INCREF(obj);
14212 return Py_BuildValue((char *)"");
14213 }
14214 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj;
14216 wxANIHandler *result;
14217 char *kwnames[] = {
14218 NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (wxANIHandler *)new wxANIHandler();
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14237 PyObject *obj;
14238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14239 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14240 Py_INCREF(obj);
14241 return Py_BuildValue((char *)"");
14242 }
14243 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxPNGHandler *result;
14246 char *kwnames[] = {
14247 NULL
14248 };
14249
14250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 result = (wxPNGHandler *)new wxPNGHandler();
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14266 PyObject *obj;
14267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14268 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14269 Py_INCREF(obj);
14270 return Py_BuildValue((char *)"");
14271 }
14272 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj;
14274 wxGIFHandler *result;
14275 char *kwnames[] = {
14276 NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (wxGIFHandler *)new wxGIFHandler();
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14295 PyObject *obj;
14296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14297 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14298 Py_INCREF(obj);
14299 return Py_BuildValue((char *)"");
14300 }
14301 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14302 PyObject *resultobj;
14303 wxPCXHandler *result;
14304 char *kwnames[] = {
14305 NULL
14306 };
14307
14308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 result = (wxPCXHandler *)new wxPCXHandler();
14312
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14324 PyObject *obj;
14325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14326 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14327 Py_INCREF(obj);
14328 return Py_BuildValue((char *)"");
14329 }
14330 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14331 PyObject *resultobj;
14332 wxJPEGHandler *result;
14333 char *kwnames[] = {
14334 NULL
14335 };
14336
14337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 result = (wxJPEGHandler *)new wxJPEGHandler();
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14353 PyObject *obj;
14354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14355 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14356 Py_INCREF(obj);
14357 return Py_BuildValue((char *)"");
14358 }
14359 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14360 PyObject *resultobj;
14361 wxPNMHandler *result;
14362 char *kwnames[] = {
14363 NULL
14364 };
14365
14366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (wxPNMHandler *)new wxPNMHandler();
14370
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14382 PyObject *obj;
14383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14384 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14385 Py_INCREF(obj);
14386 return Py_BuildValue((char *)"");
14387 }
14388 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxXPMHandler *result;
14391 char *kwnames[] = {
14392 NULL
14393 };
14394
14395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (wxXPMHandler *)new wxXPMHandler();
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14411 PyObject *obj;
14412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14413 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14414 Py_INCREF(obj);
14415 return Py_BuildValue((char *)"");
14416 }
14417 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj;
14419 wxTIFFHandler *result;
14420 char *kwnames[] = {
14421 NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (wxTIFFHandler *)new wxTIFFHandler();
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14433 return resultobj;
14434 fail:
14435 return NULL;
14436 }
14437
14438
14439 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14440 PyObject *obj;
14441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14442 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14443 Py_INCREF(obj);
14444 return Py_BuildValue((char *)"");
14445 }
14446 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14447 PyObject *resultobj;
14448 wxImage *arg1 = 0 ;
14449 wxImage *arg2 = 0 ;
14450 int arg3 = (int) 236 ;
14451 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14452 bool result;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 PyObject * obj3 = 0 ;
14457 char *kwnames[] = {
14458 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14459 };
14460
14461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14462 {
14463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14464 if (SWIG_arg_fail(1)) SWIG_fail;
14465 if (arg1 == NULL) {
14466 SWIG_null_ref("wxImage");
14467 }
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 }
14470 {
14471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14472 if (SWIG_arg_fail(2)) SWIG_fail;
14473 if (arg2 == NULL) {
14474 SWIG_null_ref("wxImage");
14475 }
14476 if (SWIG_arg_fail(2)) SWIG_fail;
14477 }
14478 if (obj2) {
14479 {
14480 arg3 = (int)(SWIG_As_int(obj2));
14481 if (SWIG_arg_fail(3)) SWIG_fail;
14482 }
14483 }
14484 if (obj3) {
14485 {
14486 arg4 = (int)(SWIG_As_int(obj3));
14487 if (SWIG_arg_fail(4)) SWIG_fail;
14488 }
14489 }
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14493
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 {
14498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14499 }
14500 return resultobj;
14501 fail:
14502 return NULL;
14503 }
14504
14505
14506 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14507 PyObject *obj;
14508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14509 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14510 Py_INCREF(obj);
14511 return Py_BuildValue((char *)"");
14512 }
14513 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxEvtHandler *result;
14516 char *kwnames[] = {
14517 NULL
14518 };
14519
14520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (wxEvtHandler *)new wxEvtHandler();
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14538 wxEvtHandler *result;
14539 PyObject * obj0 = 0 ;
14540 char *kwnames[] = {
14541 (char *) "self", NULL
14542 };
14543
14544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14546 if (SWIG_arg_fail(1)) SWIG_fail;
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14550
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 {
14555 resultobj = wxPyMake_wxObject(result, 0);
14556 }
14557 return resultobj;
14558 fail:
14559 return NULL;
14560 }
14561
14562
14563 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj;
14565 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14566 wxEvtHandler *result;
14567 PyObject * obj0 = 0 ;
14568 char *kwnames[] = {
14569 (char *) "self", NULL
14570 };
14571
14572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14574 if (SWIG_arg_fail(1)) SWIG_fail;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14578
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 {
14583 resultobj = wxPyMake_wxObject(result, 0);
14584 }
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14594 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14595 PyObject * obj0 = 0 ;
14596 PyObject * obj1 = 0 ;
14597 char *kwnames[] = {
14598 (char *) "self",(char *) "handler", NULL
14599 };
14600
14601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14603 if (SWIG_arg_fail(1)) SWIG_fail;
14604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14605 if (SWIG_arg_fail(2)) SWIG_fail;
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 (arg1)->SetNextHandler(arg2);
14609
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 Py_INCREF(Py_None); resultobj = Py_None;
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14621 PyObject *resultobj;
14622 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14623 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 char *kwnames[] = {
14627 (char *) "self",(char *) "handler", NULL
14628 };
14629
14630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14632 if (SWIG_arg_fail(1)) SWIG_fail;
14633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14634 if (SWIG_arg_fail(2)) SWIG_fail;
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 (arg1)->SetPreviousHandler(arg2);
14638
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 Py_INCREF(Py_None); resultobj = Py_None;
14643 return resultobj;
14644 fail:
14645 return NULL;
14646 }
14647
14648
14649 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj;
14651 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14652 bool result;
14653 PyObject * obj0 = 0 ;
14654 char *kwnames[] = {
14655 (char *) "self", NULL
14656 };
14657
14658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14660 if (SWIG_arg_fail(1)) SWIG_fail;
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (bool)(arg1)->GetEvtHandlerEnabled();
14664
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 {
14669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14670 }
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14678 PyObject *resultobj;
14679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14680 bool arg2 ;
14681 PyObject * obj0 = 0 ;
14682 PyObject * obj1 = 0 ;
14683 char *kwnames[] = {
14684 (char *) "self",(char *) "enabled", NULL
14685 };
14686
14687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14689 if (SWIG_arg_fail(1)) SWIG_fail;
14690 {
14691 arg2 = (bool)(SWIG_As_bool(obj1));
14692 if (SWIG_arg_fail(2)) SWIG_fail;
14693 }
14694 {
14695 PyThreadState* __tstate = wxPyBeginAllowThreads();
14696 (arg1)->SetEvtHandlerEnabled(arg2);
14697
14698 wxPyEndAllowThreads(__tstate);
14699 if (PyErr_Occurred()) SWIG_fail;
14700 }
14701 Py_INCREF(Py_None); resultobj = Py_None;
14702 return resultobj;
14703 fail:
14704 return NULL;
14705 }
14706
14707
14708 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14709 PyObject *resultobj;
14710 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14711 wxEvent *arg2 = 0 ;
14712 bool result;
14713 PyObject * obj0 = 0 ;
14714 PyObject * obj1 = 0 ;
14715 char *kwnames[] = {
14716 (char *) "self",(char *) "event", NULL
14717 };
14718
14719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14721 if (SWIG_arg_fail(1)) SWIG_fail;
14722 {
14723 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14724 if (SWIG_arg_fail(2)) SWIG_fail;
14725 if (arg2 == NULL) {
14726 SWIG_null_ref("wxEvent");
14727 }
14728 if (SWIG_arg_fail(2)) SWIG_fail;
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (bool)(arg1)->ProcessEvent(*arg2);
14733
14734 wxPyEndAllowThreads(__tstate);
14735 if (PyErr_Occurred()) SWIG_fail;
14736 }
14737 {
14738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14739 }
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj;
14748 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14749 wxEvent *arg2 = 0 ;
14750 PyObject * obj0 = 0 ;
14751 PyObject * obj1 = 0 ;
14752 char *kwnames[] = {
14753 (char *) "self",(char *) "event", NULL
14754 };
14755
14756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14758 if (SWIG_arg_fail(1)) SWIG_fail;
14759 {
14760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14761 if (SWIG_arg_fail(2)) SWIG_fail;
14762 if (arg2 == NULL) {
14763 SWIG_null_ref("wxEvent");
14764 }
14765 if (SWIG_arg_fail(2)) SWIG_fail;
14766 }
14767 {
14768 PyThreadState* __tstate = wxPyBeginAllowThreads();
14769 (arg1)->AddPendingEvent(*arg2);
14770
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 Py_INCREF(Py_None); resultobj = Py_None;
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14782 PyObject *resultobj;
14783 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14784 PyObject * obj0 = 0 ;
14785 char *kwnames[] = {
14786 (char *) "self", NULL
14787 };
14788
14789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14791 if (SWIG_arg_fail(1)) SWIG_fail;
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 (arg1)->ProcessPendingEvents();
14795
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 Py_INCREF(Py_None); resultobj = Py_None;
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj;
14808 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14809 int arg2 ;
14810 int arg3 ;
14811 int arg4 ;
14812 PyObject *arg5 = (PyObject *) 0 ;
14813 PyObject * obj0 = 0 ;
14814 PyObject * obj1 = 0 ;
14815 PyObject * obj2 = 0 ;
14816 PyObject * obj3 = 0 ;
14817 PyObject * obj4 = 0 ;
14818 char *kwnames[] = {
14819 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14820 };
14821
14822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14824 if (SWIG_arg_fail(1)) SWIG_fail;
14825 {
14826 arg2 = (int)(SWIG_As_int(obj1));
14827 if (SWIG_arg_fail(2)) SWIG_fail;
14828 }
14829 {
14830 arg3 = (int)(SWIG_As_int(obj2));
14831 if (SWIG_arg_fail(3)) SWIG_fail;
14832 }
14833 {
14834 arg4 = (int)(SWIG_As_int(obj3));
14835 if (SWIG_arg_fail(4)) SWIG_fail;
14836 }
14837 arg5 = obj4;
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 Py_INCREF(Py_None); resultobj = Py_None;
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14855 int arg2 ;
14856 int arg3 = (int) -1 ;
14857 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14858 bool result;
14859 PyObject * obj0 = 0 ;
14860 PyObject * obj1 = 0 ;
14861 PyObject * obj2 = 0 ;
14862 PyObject * obj3 = 0 ;
14863 char *kwnames[] = {
14864 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14865 };
14866
14867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14869 if (SWIG_arg_fail(1)) SWIG_fail;
14870 {
14871 arg2 = (int)(SWIG_As_int(obj1));
14872 if (SWIG_arg_fail(2)) SWIG_fail;
14873 }
14874 if (obj2) {
14875 {
14876 arg3 = (int)(SWIG_As_int(obj2));
14877 if (SWIG_arg_fail(3)) SWIG_fail;
14878 }
14879 }
14880 if (obj3) {
14881 {
14882 arg4 = (wxEventType)(SWIG_As_int(obj3));
14883 if (SWIG_arg_fail(4)) SWIG_fail;
14884 }
14885 }
14886 {
14887 PyThreadState* __tstate = wxPyBeginAllowThreads();
14888 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14889
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 {
14894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14895 }
14896 return resultobj;
14897 fail:
14898 return NULL;
14899 }
14900
14901
14902 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14903 PyObject *resultobj;
14904 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14905 PyObject *arg2 = (PyObject *) 0 ;
14906 bool arg3 = (bool) true ;
14907 PyObject * obj0 = 0 ;
14908 PyObject * obj1 = 0 ;
14909 PyObject * obj2 = 0 ;
14910 char *kwnames[] = {
14911 (char *) "self",(char *) "_self",(char *) "incref", NULL
14912 };
14913
14914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14916 if (SWIG_arg_fail(1)) SWIG_fail;
14917 arg2 = obj1;
14918 if (obj2) {
14919 {
14920 arg3 = (bool)(SWIG_As_bool(obj2));
14921 if (SWIG_arg_fail(3)) SWIG_fail;
14922 }
14923 }
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
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 * EvtHandler_swigregister(PyObject *, PyObject *args) {
14939 PyObject *obj;
14940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14941 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14942 Py_INCREF(obj);
14943 return Py_BuildValue((char *)"");
14944 }
14945 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj;
14947 wxEventType result;
14948 char *kwnames[] = {
14949 NULL
14950 };
14951
14952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 result = (wxEventType)wxNewEventType();
14956
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 {
14961 resultobj = SWIG_From_int((int)(result));
14962 }
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxEvent *arg1 = (wxEvent *) 0 ;
14972 PyObject * obj0 = 0 ;
14973 char *kwnames[] = {
14974 (char *) "self", NULL
14975 };
14976
14977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14979 if (SWIG_arg_fail(1)) SWIG_fail;
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 delete arg1;
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 Py_INCREF(Py_None); resultobj = Py_None;
14988 return resultobj;
14989 fail:
14990 return NULL;
14991 }
14992
14993
14994 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14995 PyObject *resultobj;
14996 wxEvent *arg1 = (wxEvent *) 0 ;
14997 wxEventType arg2 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 char *kwnames[] = {
15001 (char *) "self",(char *) "typ", NULL
15002 };
15003
15004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15006 if (SWIG_arg_fail(1)) SWIG_fail;
15007 {
15008 arg2 = (wxEventType)(SWIG_As_int(obj1));
15009 if (SWIG_arg_fail(2)) SWIG_fail;
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 (arg1)->SetEventType(arg2);
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 Py_INCREF(Py_None); resultobj = Py_None;
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj;
15027 wxEvent *arg1 = (wxEvent *) 0 ;
15028 wxEventType result;
15029 PyObject * obj0 = 0 ;
15030 char *kwnames[] = {
15031 (char *) "self", NULL
15032 };
15033
15034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15036 if (SWIG_arg_fail(1)) SWIG_fail;
15037 {
15038 PyThreadState* __tstate = wxPyBeginAllowThreads();
15039 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15040
15041 wxPyEndAllowThreads(__tstate);
15042 if (PyErr_Occurred()) SWIG_fail;
15043 }
15044 {
15045 resultobj = SWIG_From_int((int)(result));
15046 }
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj;
15055 wxEvent *arg1 = (wxEvent *) 0 ;
15056 wxObject *result;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 {
15073 resultobj = wxPyMake_wxObject(result, 0);
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxEvent *arg1 = (wxEvent *) 0 ;
15084 wxObject *arg2 = (wxObject *) 0 ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 char *kwnames[] = {
15088 (char *) "self",(char *) "obj", NULL
15089 };
15090
15091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15093 if (SWIG_arg_fail(1)) SWIG_fail;
15094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(2)) SWIG_fail;
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 (arg1)->SetEventObject(arg2);
15099
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 Py_INCREF(Py_None); resultobj = Py_None;
15104 return resultobj;
15105 fail:
15106 return NULL;
15107 }
15108
15109
15110 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15111 PyObject *resultobj;
15112 wxEvent *arg1 = (wxEvent *) 0 ;
15113 long result;
15114 PyObject * obj0 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15125
15126 wxPyEndAllowThreads(__tstate);
15127 if (PyErr_Occurred()) SWIG_fail;
15128 }
15129 {
15130 resultobj = SWIG_From_long((long)(result));
15131 }
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj;
15140 wxEvent *arg1 = (wxEvent *) 0 ;
15141 long arg2 = (long) 0 ;
15142 PyObject * obj0 = 0 ;
15143 PyObject * obj1 = 0 ;
15144 char *kwnames[] = {
15145 (char *) "self",(char *) "ts", NULL
15146 };
15147
15148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15150 if (SWIG_arg_fail(1)) SWIG_fail;
15151 if (obj1) {
15152 {
15153 arg2 = (long)(SWIG_As_long(obj1));
15154 if (SWIG_arg_fail(2)) SWIG_fail;
15155 }
15156 }
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 (arg1)->SetTimestamp(arg2);
15160
15161 wxPyEndAllowThreads(__tstate);
15162 if (PyErr_Occurred()) SWIG_fail;
15163 }
15164 Py_INCREF(Py_None); resultobj = Py_None;
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15172 PyObject *resultobj;
15173 wxEvent *arg1 = (wxEvent *) 0 ;
15174 int result;
15175 PyObject * obj0 = 0 ;
15176 char *kwnames[] = {
15177 (char *) "self", NULL
15178 };
15179
15180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15182 if (SWIG_arg_fail(1)) SWIG_fail;
15183 {
15184 PyThreadState* __tstate = wxPyBeginAllowThreads();
15185 result = (int)((wxEvent const *)arg1)->GetId();
15186
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 {
15191 resultobj = SWIG_From_int((int)(result));
15192 }
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj;
15201 wxEvent *arg1 = (wxEvent *) 0 ;
15202 int arg2 ;
15203 PyObject * obj0 = 0 ;
15204 PyObject * obj1 = 0 ;
15205 char *kwnames[] = {
15206 (char *) "self",(char *) "Id", NULL
15207 };
15208
15209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15211 if (SWIG_arg_fail(1)) SWIG_fail;
15212 {
15213 arg2 = (int)(SWIG_As_int(obj1));
15214 if (SWIG_arg_fail(2)) SWIG_fail;
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 (arg1)->SetId(arg2);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 Py_INCREF(Py_None); resultobj = Py_None;
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj;
15232 wxEvent *arg1 = (wxEvent *) 0 ;
15233 bool result;
15234 PyObject * obj0 = 0 ;
15235 char *kwnames[] = {
15236 (char *) "self", NULL
15237 };
15238
15239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15241 if (SWIG_arg_fail(1)) SWIG_fail;
15242 {
15243 PyThreadState* __tstate = wxPyBeginAllowThreads();
15244 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15245
15246 wxPyEndAllowThreads(__tstate);
15247 if (PyErr_Occurred()) SWIG_fail;
15248 }
15249 {
15250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15251 }
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxEvent *arg1 = (wxEvent *) 0 ;
15261 bool arg2 = (bool) true ;
15262 PyObject * obj0 = 0 ;
15263 PyObject * obj1 = 0 ;
15264 char *kwnames[] = {
15265 (char *) "self",(char *) "skip", NULL
15266 };
15267
15268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15270 if (SWIG_arg_fail(1)) SWIG_fail;
15271 if (obj1) {
15272 {
15273 arg2 = (bool)(SWIG_As_bool(obj1));
15274 if (SWIG_arg_fail(2)) SWIG_fail;
15275 }
15276 }
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->Skip(arg2);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 Py_INCREF(Py_None); resultobj = Py_None;
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj;
15293 wxEvent *arg1 = (wxEvent *) 0 ;
15294 bool result;
15295 PyObject * obj0 = 0 ;
15296 char *kwnames[] = {
15297 (char *) "self", NULL
15298 };
15299
15300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",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 = (bool)((wxEvent const *)arg1)->GetSkipped();
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 {
15311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15312 }
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxEvent *arg1 = (wxEvent *) 0 ;
15322 bool result;
15323 PyObject * obj0 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxEvent *arg1 = (wxEvent *) 0 ;
15350 int result;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (int)(arg1)->StopPropagation();
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 {
15367 resultobj = SWIG_From_int((int)(result));
15368 }
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj;
15377 wxEvent *arg1 = (wxEvent *) 0 ;
15378 int arg2 ;
15379 PyObject * obj0 = 0 ;
15380 PyObject * obj1 = 0 ;
15381 char *kwnames[] = {
15382 (char *) "self",(char *) "propagationLevel", NULL
15383 };
15384
15385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15387 if (SWIG_arg_fail(1)) SWIG_fail;
15388 {
15389 arg2 = (int)(SWIG_As_int(obj1));
15390 if (SWIG_arg_fail(2)) SWIG_fail;
15391 }
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 (arg1)->ResumePropagation(arg2);
15395
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 Py_INCREF(Py_None); resultobj = Py_None;
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj;
15408 wxEvent *arg1 = (wxEvent *) 0 ;
15409 wxEvent *result;
15410 PyObject * obj0 = 0 ;
15411 char *kwnames[] = {
15412 (char *) "self", NULL
15413 };
15414
15415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15417 if (SWIG_arg_fail(1)) SWIG_fail;
15418 {
15419 PyThreadState* __tstate = wxPyBeginAllowThreads();
15420 result = (wxEvent *)(arg1)->Clone();
15421
15422 wxPyEndAllowThreads(__tstate);
15423 if (PyErr_Occurred()) SWIG_fail;
15424 }
15425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15426 return resultobj;
15427 fail:
15428 return NULL;
15429 }
15430
15431
15432 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15433 PyObject *obj;
15434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15435 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15436 Py_INCREF(obj);
15437 return Py_BuildValue((char *)"");
15438 }
15439 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15440 PyObject *resultobj;
15441 wxEvent *arg1 = 0 ;
15442 wxPropagationDisabler *result;
15443 PyObject * obj0 = 0 ;
15444 char *kwnames[] = {
15445 (char *) "event", NULL
15446 };
15447
15448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15449 {
15450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15451 if (SWIG_arg_fail(1)) SWIG_fail;
15452 if (arg1 == NULL) {
15453 SWIG_null_ref("wxEvent");
15454 }
15455 if (SWIG_arg_fail(1)) SWIG_fail;
15456 }
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15460
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15474 PyObject * obj0 = 0 ;
15475 char *kwnames[] = {
15476 (char *) "self", NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 delete arg1;
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 Py_INCREF(Py_None); resultobj = Py_None;
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15497 PyObject *obj;
15498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15499 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15500 Py_INCREF(obj);
15501 return Py_BuildValue((char *)"");
15502 }
15503 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj;
15505 wxEvent *arg1 = 0 ;
15506 wxPropagateOnce *result;
15507 PyObject * obj0 = 0 ;
15508 char *kwnames[] = {
15509 (char *) "event", NULL
15510 };
15511
15512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15513 {
15514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15515 if (SWIG_arg_fail(1)) SWIG_fail;
15516 if (arg1 == NULL) {
15517 SWIG_null_ref("wxEvent");
15518 }
15519 if (SWIG_arg_fail(1)) SWIG_fail;
15520 }
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15524
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15529 return resultobj;
15530 fail:
15531 return NULL;
15532 }
15533
15534
15535 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15536 PyObject *resultobj;
15537 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15538 PyObject * obj0 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 delete arg1;
15549
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 Py_INCREF(Py_None); resultobj = Py_None;
15554 return resultobj;
15555 fail:
15556 return NULL;
15557 }
15558
15559
15560 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15561 PyObject *obj;
15562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15563 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15564 Py_INCREF(obj);
15565 return Py_BuildValue((char *)"");
15566 }
15567 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15570 int arg2 = (int) 0 ;
15571 wxCommandEvent *result;
15572 PyObject * obj0 = 0 ;
15573 PyObject * obj1 = 0 ;
15574 char *kwnames[] = {
15575 (char *) "commandType",(char *) "winid", NULL
15576 };
15577
15578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15579 if (obj0) {
15580 {
15581 arg1 = (wxEventType)(SWIG_As_int(obj0));
15582 if (SWIG_arg_fail(1)) SWIG_fail;
15583 }
15584 }
15585 if (obj1) {
15586 {
15587 arg2 = (int)(SWIG_As_int(obj1));
15588 if (SWIG_arg_fail(2)) SWIG_fail;
15589 }
15590 }
15591 {
15592 PyThreadState* __tstate = wxPyBeginAllowThreads();
15593 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15594
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15599 return resultobj;
15600 fail:
15601 return NULL;
15602 }
15603
15604
15605 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15606 PyObject *resultobj;
15607 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15608 int result;
15609 PyObject * obj0 = 0 ;
15610 char *kwnames[] = {
15611 (char *) "self", NULL
15612 };
15613
15614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15616 if (SWIG_arg_fail(1)) SWIG_fail;
15617 {
15618 PyThreadState* __tstate = wxPyBeginAllowThreads();
15619 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15620
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 {
15625 resultobj = SWIG_From_int((int)(result));
15626 }
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj;
15635 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15636 wxString *arg2 = 0 ;
15637 bool temp2 = false ;
15638 PyObject * obj0 = 0 ;
15639 PyObject * obj1 = 0 ;
15640 char *kwnames[] = {
15641 (char *) "self",(char *) "s", NULL
15642 };
15643
15644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15646 if (SWIG_arg_fail(1)) SWIG_fail;
15647 {
15648 arg2 = wxString_in_helper(obj1);
15649 if (arg2 == NULL) SWIG_fail;
15650 temp2 = true;
15651 }
15652 {
15653 PyThreadState* __tstate = wxPyBeginAllowThreads();
15654 (arg1)->SetString((wxString const &)*arg2);
15655
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 Py_INCREF(Py_None); resultobj = Py_None;
15660 {
15661 if (temp2)
15662 delete arg2;
15663 }
15664 return resultobj;
15665 fail:
15666 {
15667 if (temp2)
15668 delete arg2;
15669 }
15670 return NULL;
15671 }
15672
15673
15674 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15675 PyObject *resultobj;
15676 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15677 wxString result;
15678 PyObject * obj0 = 0 ;
15679 char *kwnames[] = {
15680 (char *) "self", NULL
15681 };
15682
15683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15685 if (SWIG_arg_fail(1)) SWIG_fail;
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 result = ((wxCommandEvent const *)arg1)->GetString();
15689
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 {
15694 #if wxUSE_UNICODE
15695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15696 #else
15697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15698 #endif
15699 }
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15707 PyObject *resultobj;
15708 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15709 bool result;
15710 PyObject * obj0 = 0 ;
15711 char *kwnames[] = {
15712 (char *) "self", NULL
15713 };
15714
15715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15717 if (SWIG_arg_fail(1)) SWIG_fail;
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15721
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 {
15726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15737 bool result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj;
15764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15765 long arg2 ;
15766 PyObject * obj0 = 0 ;
15767 PyObject * obj1 = 0 ;
15768 char *kwnames[] = {
15769 (char *) "self",(char *) "extraLong", NULL
15770 };
15771
15772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15774 if (SWIG_arg_fail(1)) SWIG_fail;
15775 {
15776 arg2 = (long)(SWIG_As_long(obj1));
15777 if (SWIG_arg_fail(2)) SWIG_fail;
15778 }
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 (arg1)->SetExtraLong(arg2);
15782
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 Py_INCREF(Py_None); resultobj = Py_None;
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj;
15795 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15796 long result;
15797 PyObject * obj0 = 0 ;
15798 char *kwnames[] = {
15799 (char *) "self", NULL
15800 };
15801
15802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(1)) SWIG_fail;
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15808
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 {
15813 resultobj = SWIG_From_long((long)(result));
15814 }
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15824 int arg2 ;
15825 PyObject * obj0 = 0 ;
15826 PyObject * obj1 = 0 ;
15827 char *kwnames[] = {
15828 (char *) "self",(char *) "i", NULL
15829 };
15830
15831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15833 if (SWIG_arg_fail(1)) SWIG_fail;
15834 {
15835 arg2 = (int)(SWIG_As_int(obj1));
15836 if (SWIG_arg_fail(2)) SWIG_fail;
15837 }
15838 {
15839 PyThreadState* __tstate = wxPyBeginAllowThreads();
15840 (arg1)->SetInt(arg2);
15841
15842 wxPyEndAllowThreads(__tstate);
15843 if (PyErr_Occurred()) SWIG_fail;
15844 }
15845 Py_INCREF(Py_None); resultobj = Py_None;
15846 return resultobj;
15847 fail:
15848 return NULL;
15849 }
15850
15851
15852 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15853 PyObject *resultobj;
15854 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15855 long result;
15856 PyObject * obj0 = 0 ;
15857 char *kwnames[] = {
15858 (char *) "self", NULL
15859 };
15860
15861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15863 if (SWIG_arg_fail(1)) SWIG_fail;
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15867
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 {
15872 resultobj = SWIG_From_long((long)(result));
15873 }
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15883 wxEvent *result;
15884 PyObject * obj0 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "self", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15891 if (SWIG_arg_fail(1)) SWIG_fail;
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15895
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15907 PyObject *obj;
15908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15909 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15910 Py_INCREF(obj);
15911 return Py_BuildValue((char *)"");
15912 }
15913 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15916 int arg2 = (int) 0 ;
15917 wxNotifyEvent *result;
15918 PyObject * obj0 = 0 ;
15919 PyObject * obj1 = 0 ;
15920 char *kwnames[] = {
15921 (char *) "commandType",(char *) "winid", NULL
15922 };
15923
15924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15925 if (obj0) {
15926 {
15927 arg1 = (wxEventType)(SWIG_As_int(obj0));
15928 if (SWIG_arg_fail(1)) SWIG_fail;
15929 }
15930 }
15931 if (obj1) {
15932 {
15933 arg2 = (int)(SWIG_As_int(obj1));
15934 if (SWIG_arg_fail(2)) SWIG_fail;
15935 }
15936 }
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15940
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj;
15953 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15954 PyObject * obj0 = 0 ;
15955 char *kwnames[] = {
15956 (char *) "self", NULL
15957 };
15958
15959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15961 if (SWIG_arg_fail(1)) SWIG_fail;
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 (arg1)->Veto();
15965
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 Py_INCREF(Py_None); resultobj = Py_None;
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj;
15978 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15979 PyObject * obj0 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 (arg1)->Allow();
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 Py_INCREF(Py_None); resultobj = Py_None;
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16004 bool result;
16005 PyObject * obj0 = 0 ;
16006 char *kwnames[] = {
16007 (char *) "self", NULL
16008 };
16009
16010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16012 if (SWIG_arg_fail(1)) SWIG_fail;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)(arg1)->IsAllowed();
16016
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16030 PyObject *obj;
16031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16032 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16033 Py_INCREF(obj);
16034 return Py_BuildValue((char *)"");
16035 }
16036 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj;
16038 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16039 int arg2 = (int) 0 ;
16040 int arg3 = (int) 0 ;
16041 int arg4 = (int) 0 ;
16042 wxScrollEvent *result;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 PyObject * obj2 = 0 ;
16046 PyObject * obj3 = 0 ;
16047 char *kwnames[] = {
16048 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16049 };
16050
16051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16052 if (obj0) {
16053 {
16054 arg1 = (wxEventType)(SWIG_As_int(obj0));
16055 if (SWIG_arg_fail(1)) SWIG_fail;
16056 }
16057 }
16058 if (obj1) {
16059 {
16060 arg2 = (int)(SWIG_As_int(obj1));
16061 if (SWIG_arg_fail(2)) SWIG_fail;
16062 }
16063 }
16064 if (obj2) {
16065 {
16066 arg3 = (int)(SWIG_As_int(obj2));
16067 if (SWIG_arg_fail(3)) SWIG_fail;
16068 }
16069 }
16070 if (obj3) {
16071 {
16072 arg4 = (int)(SWIG_As_int(obj3));
16073 if (SWIG_arg_fail(4)) SWIG_fail;
16074 }
16075 }
16076 {
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16079
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj;
16092 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16093 int result;
16094 PyObject * obj0 = 0 ;
16095 char *kwnames[] = {
16096 (char *) "self", NULL
16097 };
16098
16099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16101 if (SWIG_arg_fail(1)) SWIG_fail;
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16105
16106 wxPyEndAllowThreads(__tstate);
16107 if (PyErr_Occurred()) SWIG_fail;
16108 }
16109 {
16110 resultobj = SWIG_From_int((int)(result));
16111 }
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16121 int result;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = SWIG_From_int((int)(result));
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj;
16148 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16149 int arg2 ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 char *kwnames[] = {
16153 (char *) "self",(char *) "orient", NULL
16154 };
16155
16156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16158 if (SWIG_arg_fail(1)) SWIG_fail;
16159 {
16160 arg2 = (int)(SWIG_As_int(obj1));
16161 if (SWIG_arg_fail(2)) SWIG_fail;
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 (arg1)->SetOrientation(arg2);
16166
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 Py_INCREF(Py_None); resultobj = Py_None;
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj;
16179 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16180 int arg2 ;
16181 PyObject * obj0 = 0 ;
16182 PyObject * obj1 = 0 ;
16183 char *kwnames[] = {
16184 (char *) "self",(char *) "pos", NULL
16185 };
16186
16187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16189 if (SWIG_arg_fail(1)) SWIG_fail;
16190 {
16191 arg2 = (int)(SWIG_As_int(obj1));
16192 if (SWIG_arg_fail(2)) SWIG_fail;
16193 }
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 (arg1)->SetPosition(arg2);
16197
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 Py_INCREF(Py_None); resultobj = Py_None;
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16209 PyObject *obj;
16210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16211 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16212 Py_INCREF(obj);
16213 return Py_BuildValue((char *)"");
16214 }
16215 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj;
16217 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16218 int arg2 = (int) 0 ;
16219 int arg3 = (int) 0 ;
16220 wxScrollWinEvent *result;
16221 PyObject * obj0 = 0 ;
16222 PyObject * obj1 = 0 ;
16223 PyObject * obj2 = 0 ;
16224 char *kwnames[] = {
16225 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16226 };
16227
16228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16229 if (obj0) {
16230 {
16231 arg1 = (wxEventType)(SWIG_As_int(obj0));
16232 if (SWIG_arg_fail(1)) SWIG_fail;
16233 }
16234 }
16235 if (obj1) {
16236 {
16237 arg2 = (int)(SWIG_As_int(obj1));
16238 if (SWIG_arg_fail(2)) SWIG_fail;
16239 }
16240 }
16241 if (obj2) {
16242 {
16243 arg3 = (int)(SWIG_As_int(obj2));
16244 if (SWIG_arg_fail(3)) SWIG_fail;
16245 }
16246 }
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16264 int result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = SWIG_From_int((int)(result));
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16292 int result;
16293 PyObject * obj0 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16304
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = SWIG_From_int((int)(result));
16310 }
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16320 int arg2 ;
16321 PyObject * obj0 = 0 ;
16322 PyObject * obj1 = 0 ;
16323 char *kwnames[] = {
16324 (char *) "self",(char *) "orient", NULL
16325 };
16326
16327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16329 if (SWIG_arg_fail(1)) SWIG_fail;
16330 {
16331 arg2 = (int)(SWIG_As_int(obj1));
16332 if (SWIG_arg_fail(2)) SWIG_fail;
16333 }
16334 {
16335 PyThreadState* __tstate = wxPyBeginAllowThreads();
16336 (arg1)->SetOrientation(arg2);
16337
16338 wxPyEndAllowThreads(__tstate);
16339 if (PyErr_Occurred()) SWIG_fail;
16340 }
16341 Py_INCREF(Py_None); resultobj = Py_None;
16342 return resultobj;
16343 fail:
16344 return NULL;
16345 }
16346
16347
16348 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj;
16350 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16351 int arg2 ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 char *kwnames[] = {
16355 (char *) "self",(char *) "pos", NULL
16356 };
16357
16358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16360 if (SWIG_arg_fail(1)) SWIG_fail;
16361 {
16362 arg2 = (int)(SWIG_As_int(obj1));
16363 if (SWIG_arg_fail(2)) SWIG_fail;
16364 }
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetPosition(arg2);
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 Py_INCREF(Py_None); resultobj = Py_None;
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16380 PyObject *obj;
16381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16382 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16383 Py_INCREF(obj);
16384 return Py_BuildValue((char *)"");
16385 }
16386 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj;
16388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16389 wxMouseEvent *result;
16390 PyObject * obj0 = 0 ;
16391 char *kwnames[] = {
16392 (char *) "mouseType", NULL
16393 };
16394
16395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16396 if (obj0) {
16397 {
16398 arg1 = (wxEventType)(SWIG_As_int(obj0));
16399 if (SWIG_arg_fail(1)) SWIG_fail;
16400 }
16401 }
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16405
16406 wxPyEndAllowThreads(__tstate);
16407 if (PyErr_Occurred()) SWIG_fail;
16408 }
16409 {
16410 resultobj = wxPyMake_wxObject(result, 1);
16411 }
16412 return resultobj;
16413 fail:
16414 return NULL;
16415 }
16416
16417
16418 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16419 PyObject *resultobj;
16420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16421 bool result;
16422 PyObject * obj0 = 0 ;
16423 char *kwnames[] = {
16424 (char *) "self", NULL
16425 };
16426
16427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16429 if (SWIG_arg_fail(1)) SWIG_fail;
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 {
16438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16439 }
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16449 int arg2 = (int) wxMOUSE_BTN_ANY ;
16450 bool result;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 char *kwnames[] = {
16454 (char *) "self",(char *) "but", NULL
16455 };
16456
16457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16459 if (SWIG_arg_fail(1)) SWIG_fail;
16460 if (obj1) {
16461 {
16462 arg2 = (int)(SWIG_As_int(obj1));
16463 if (SWIG_arg_fail(2)) SWIG_fail;
16464 }
16465 }
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16469
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 return resultobj;
16477 fail:
16478 return NULL;
16479 }
16480
16481
16482 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16483 PyObject *resultobj;
16484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16485 int arg2 = (int) wxMOUSE_BTN_ANY ;
16486 bool result;
16487 PyObject * obj0 = 0 ;
16488 PyObject * obj1 = 0 ;
16489 char *kwnames[] = {
16490 (char *) "self",(char *) "but", NULL
16491 };
16492
16493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16495 if (SWIG_arg_fail(1)) SWIG_fail;
16496 if (obj1) {
16497 {
16498 arg2 = (int)(SWIG_As_int(obj1));
16499 if (SWIG_arg_fail(2)) SWIG_fail;
16500 }
16501 }
16502 {
16503 PyThreadState* __tstate = wxPyBeginAllowThreads();
16504 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16505
16506 wxPyEndAllowThreads(__tstate);
16507 if (PyErr_Occurred()) SWIG_fail;
16508 }
16509 {
16510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16511 }
16512 return resultobj;
16513 fail:
16514 return NULL;
16515 }
16516
16517
16518 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16519 PyObject *resultobj;
16520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16521 int arg2 = (int) wxMOUSE_BTN_ANY ;
16522 bool result;
16523 PyObject * obj0 = 0 ;
16524 PyObject * obj1 = 0 ;
16525 char *kwnames[] = {
16526 (char *) "self",(char *) "but", NULL
16527 };
16528
16529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16531 if (SWIG_arg_fail(1)) SWIG_fail;
16532 if (obj1) {
16533 {
16534 arg2 = (int)(SWIG_As_int(obj1));
16535 if (SWIG_arg_fail(2)) SWIG_fail;
16536 }
16537 }
16538 {
16539 PyThreadState* __tstate = wxPyBeginAllowThreads();
16540 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16541
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16547 }
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16555 PyObject *resultobj;
16556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16557 int arg2 ;
16558 bool result;
16559 PyObject * obj0 = 0 ;
16560 PyObject * obj1 = 0 ;
16561 char *kwnames[] = {
16562 (char *) "self",(char *) "button", NULL
16563 };
16564
16565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16567 if (SWIG_arg_fail(1)) SWIG_fail;
16568 {
16569 arg2 = (int)(SWIG_As_int(obj1));
16570 if (SWIG_arg_fail(2)) SWIG_fail;
16571 }
16572 {
16573 PyThreadState* __tstate = wxPyBeginAllowThreads();
16574 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16575
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 {
16580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16581 }
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj;
16590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16591 int arg2 ;
16592 bool result;
16593 PyObject * obj0 = 0 ;
16594 PyObject * obj1 = 0 ;
16595 char *kwnames[] = {
16596 (char *) "self",(char *) "but", NULL
16597 };
16598
16599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16601 if (SWIG_arg_fail(1)) SWIG_fail;
16602 {
16603 arg2 = (int)(SWIG_As_int(obj1));
16604 if (SWIG_arg_fail(2)) SWIG_fail;
16605 }
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
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_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj;
16624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16625 int result;
16626 PyObject * obj0 = 0 ;
16627 char *kwnames[] = {
16628 (char *) "self", NULL
16629 };
16630
16631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",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 = (int)((wxMouseEvent const *)arg1)->GetButton();
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = SWIG_From_int((int)(result));
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_MouseEvent_ControlDown(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_ControlDown",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)->ControlDown();
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_MetaDown(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_MetaDown",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)->MetaDown();
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_AltDown(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_AltDown",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)->AltDown();
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_ShiftDown(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_ShiftDown",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)->ShiftDown();
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_CmdDown(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_CmdDown",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)->CmdDown();
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_LeftDown(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_LeftDown",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)->LeftDown();
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_MiddleDown(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_MiddleDown",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)->MiddleDown();
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_RightDown(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_RightDown",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)->RightDown();
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_LeftUp(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_LeftUp",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)->LeftUp();
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_MiddleUp(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_MiddleUp",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)->MiddleUp();
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_RightUp(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_RightUp",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)->RightUp();
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_LeftDClick(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_LeftDClick",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)->LeftDClick();
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_MiddleDClick(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_MiddleDClick",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
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_RightDClick(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_RightDClick",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
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_LeftIsDown(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_LeftIsDown",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)->LeftIsDown();
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_MiddleIsDown(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_MiddleIsDown",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (bool)(arg1)->MiddleIsDown();
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_RightIsDown(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_RightIsDown",kwnames,&obj0)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (bool)(arg1)->RightIsDown();
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_Dragging(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_Dragging",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)->Dragging();
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_Moving(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_Moving",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)->Moving();
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_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17185 bool result;
17186 PyObject * obj0 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17241 wxPoint result;
17242 PyObject * obj0 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (arg1)->GetPosition();
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 wxPoint * resultptr;
17259 resultptr = new wxPoint((wxPoint &)(result));
17260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17261 }
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj;
17270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17271 long *arg2 = (long *) 0 ;
17272 long *arg3 = (long *) 0 ;
17273 long temp2 ;
17274 int res2 = 0 ;
17275 long temp3 ;
17276 int res3 = 0 ;
17277 PyObject * obj0 = 0 ;
17278 char *kwnames[] = {
17279 (char *) "self", NULL
17280 };
17281
17282 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17283 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17286 if (SWIG_arg_fail(1)) SWIG_fail;
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 (arg1)->GetPosition(arg2,arg3);
17290
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 Py_INCREF(Py_None); resultobj = Py_None;
17295 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17296 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17297 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17298 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj;
17307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17308 wxDC *arg2 = 0 ;
17309 wxPoint result;
17310 PyObject * obj0 = 0 ;
17311 PyObject * obj1 = 0 ;
17312 char *kwnames[] = {
17313 (char *) "self",(char *) "dc", NULL
17314 };
17315
17316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17318 if (SWIG_arg_fail(1)) SWIG_fail;
17319 {
17320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17321 if (SWIG_arg_fail(2)) SWIG_fail;
17322 if (arg2 == NULL) {
17323 SWIG_null_ref("wxDC");
17324 }
17325 if (SWIG_arg_fail(2)) SWIG_fail;
17326 }
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17330
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 {
17335 wxPoint * resultptr;
17336 resultptr = new wxPoint((wxPoint &)(result));
17337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17338 }
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_MouseEvent_GetX(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_GetX",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)->GetX();
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_GetY(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_GetY",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)->GetY();
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_GetWheelRotation(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_GetWheelRotation",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)->GetWheelRotation();
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_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 bool result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 int arg2 ;
17517 PyObject * obj0 = 0 ;
17518 PyObject * obj1 = 0 ;
17519 char *kwnames[] = {
17520 (char *) "self",(char *) "m_x", NULL
17521 };
17522
17523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17525 if (SWIG_arg_fail(1)) SWIG_fail;
17526 {
17527 arg2 = (int)(SWIG_As_int(obj1));
17528 if (SWIG_arg_fail(2)) SWIG_fail;
17529 }
17530 if (arg1) (arg1)->m_x = arg2;
17531
17532 Py_INCREF(Py_None); resultobj = Py_None;
17533 return resultobj;
17534 fail:
17535 return NULL;
17536 }
17537
17538
17539 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17540 PyObject *resultobj;
17541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17542 int result;
17543 PyObject * obj0 = 0 ;
17544 char *kwnames[] = {
17545 (char *) "self", NULL
17546 };
17547
17548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17550 if (SWIG_arg_fail(1)) SWIG_fail;
17551 result = (int) ((arg1)->m_x);
17552
17553 {
17554 resultobj = SWIG_From_int((int)(result));
17555 }
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17565 int arg2 ;
17566 PyObject * obj0 = 0 ;
17567 PyObject * obj1 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self",(char *) "m_y", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 {
17576 arg2 = (int)(SWIG_As_int(obj1));
17577 if (SWIG_arg_fail(2)) SWIG_fail;
17578 }
17579 if (arg1) (arg1)->m_y = arg2;
17580
17581 Py_INCREF(Py_None); resultobj = Py_None;
17582 return resultobj;
17583 fail:
17584 return NULL;
17585 }
17586
17587
17588 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17589 PyObject *resultobj;
17590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17591 int result;
17592 PyObject * obj0 = 0 ;
17593 char *kwnames[] = {
17594 (char *) "self", NULL
17595 };
17596
17597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17599 if (SWIG_arg_fail(1)) SWIG_fail;
17600 result = (int) ((arg1)->m_y);
17601
17602 {
17603 resultobj = SWIG_From_int((int)(result));
17604 }
17605 return resultobj;
17606 fail:
17607 return NULL;
17608 }
17609
17610
17611 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17612 PyObject *resultobj;
17613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17614 bool arg2 ;
17615 PyObject * obj0 = 0 ;
17616 PyObject * obj1 = 0 ;
17617 char *kwnames[] = {
17618 (char *) "self",(char *) "m_leftDown", NULL
17619 };
17620
17621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17623 if (SWIG_arg_fail(1)) SWIG_fail;
17624 {
17625 arg2 = (bool)(SWIG_As_bool(obj1));
17626 if (SWIG_arg_fail(2)) SWIG_fail;
17627 }
17628 if (arg1) (arg1)->m_leftDown = arg2;
17629
17630 Py_INCREF(Py_None); resultobj = Py_None;
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17638 PyObject *resultobj;
17639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17640 bool result;
17641 PyObject * obj0 = 0 ;
17642 char *kwnames[] = {
17643 (char *) "self", NULL
17644 };
17645
17646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17648 if (SWIG_arg_fail(1)) SWIG_fail;
17649 result = (bool) ((arg1)->m_leftDown);
17650
17651 {
17652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17653 }
17654 return resultobj;
17655 fail:
17656 return NULL;
17657 }
17658
17659
17660 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17661 PyObject *resultobj;
17662 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17663 bool arg2 ;
17664 PyObject * obj0 = 0 ;
17665 PyObject * obj1 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self",(char *) "m_middleDown", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 arg2 = (bool)(SWIG_As_bool(obj1));
17675 if (SWIG_arg_fail(2)) SWIG_fail;
17676 }
17677 if (arg1) (arg1)->m_middleDown = arg2;
17678
17679 Py_INCREF(Py_None); resultobj = Py_None;
17680 return resultobj;
17681 fail:
17682 return NULL;
17683 }
17684
17685
17686 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj;
17688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17689 bool result;
17690 PyObject * obj0 = 0 ;
17691 char *kwnames[] = {
17692 (char *) "self", NULL
17693 };
17694
17695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17697 if (SWIG_arg_fail(1)) SWIG_fail;
17698 result = (bool) ((arg1)->m_middleDown);
17699
17700 {
17701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17702 }
17703 return resultobj;
17704 fail:
17705 return NULL;
17706 }
17707
17708
17709 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj;
17711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17712 bool arg2 ;
17713 PyObject * obj0 = 0 ;
17714 PyObject * obj1 = 0 ;
17715 char *kwnames[] = {
17716 (char *) "self",(char *) "m_rightDown", NULL
17717 };
17718
17719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17721 if (SWIG_arg_fail(1)) SWIG_fail;
17722 {
17723 arg2 = (bool)(SWIG_As_bool(obj1));
17724 if (SWIG_arg_fail(2)) SWIG_fail;
17725 }
17726 if (arg1) (arg1)->m_rightDown = arg2;
17727
17728 Py_INCREF(Py_None); resultobj = Py_None;
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17738 bool result;
17739 PyObject * obj0 = 0 ;
17740 char *kwnames[] = {
17741 (char *) "self", NULL
17742 };
17743
17744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17746 if (SWIG_arg_fail(1)) SWIG_fail;
17747 result = (bool) ((arg1)->m_rightDown);
17748
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 return resultobj;
17753 fail:
17754 return NULL;
17755 }
17756
17757
17758 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17759 PyObject *resultobj;
17760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17761 bool arg2 ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "self",(char *) "m_controlDown", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 {
17772 arg2 = (bool)(SWIG_As_bool(obj1));
17773 if (SWIG_arg_fail(2)) SWIG_fail;
17774 }
17775 if (arg1) (arg1)->m_controlDown = arg2;
17776
17777 Py_INCREF(Py_None); resultobj = Py_None;
17778 return resultobj;
17779 fail:
17780 return NULL;
17781 }
17782
17783
17784 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj;
17786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17787 bool result;
17788 PyObject * obj0 = 0 ;
17789 char *kwnames[] = {
17790 (char *) "self", NULL
17791 };
17792
17793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17795 if (SWIG_arg_fail(1)) SWIG_fail;
17796 result = (bool) ((arg1)->m_controlDown);
17797
17798 {
17799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17800 }
17801 return resultobj;
17802 fail:
17803 return NULL;
17804 }
17805
17806
17807 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17808 PyObject *resultobj;
17809 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17810 bool arg2 ;
17811 PyObject * obj0 = 0 ;
17812 PyObject * obj1 = 0 ;
17813 char *kwnames[] = {
17814 (char *) "self",(char *) "m_shiftDown", NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17819 if (SWIG_arg_fail(1)) SWIG_fail;
17820 {
17821 arg2 = (bool)(SWIG_As_bool(obj1));
17822 if (SWIG_arg_fail(2)) SWIG_fail;
17823 }
17824 if (arg1) (arg1)->m_shiftDown = arg2;
17825
17826 Py_INCREF(Py_None); resultobj = Py_None;
17827 return resultobj;
17828 fail:
17829 return NULL;
17830 }
17831
17832
17833 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17834 PyObject *resultobj;
17835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17836 bool result;
17837 PyObject * obj0 = 0 ;
17838 char *kwnames[] = {
17839 (char *) "self", NULL
17840 };
17841
17842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17844 if (SWIG_arg_fail(1)) SWIG_fail;
17845 result = (bool) ((arg1)->m_shiftDown);
17846
17847 {
17848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17849 }
17850 return resultobj;
17851 fail:
17852 return NULL;
17853 }
17854
17855
17856 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17857 PyObject *resultobj;
17858 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17859 bool arg2 ;
17860 PyObject * obj0 = 0 ;
17861 PyObject * obj1 = 0 ;
17862 char *kwnames[] = {
17863 (char *) "self",(char *) "m_altDown", NULL
17864 };
17865
17866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17868 if (SWIG_arg_fail(1)) SWIG_fail;
17869 {
17870 arg2 = (bool)(SWIG_As_bool(obj1));
17871 if (SWIG_arg_fail(2)) SWIG_fail;
17872 }
17873 if (arg1) (arg1)->m_altDown = arg2;
17874
17875 Py_INCREF(Py_None); resultobj = Py_None;
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj;
17884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17885 bool result;
17886 PyObject * obj0 = 0 ;
17887 char *kwnames[] = {
17888 (char *) "self", NULL
17889 };
17890
17891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17893 if (SWIG_arg_fail(1)) SWIG_fail;
17894 result = (bool) ((arg1)->m_altDown);
17895
17896 {
17897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17898 }
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17908 bool arg2 ;
17909 PyObject * obj0 = 0 ;
17910 PyObject * obj1 = 0 ;
17911 char *kwnames[] = {
17912 (char *) "self",(char *) "m_metaDown", NULL
17913 };
17914
17915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17917 if (SWIG_arg_fail(1)) SWIG_fail;
17918 {
17919 arg2 = (bool)(SWIG_As_bool(obj1));
17920 if (SWIG_arg_fail(2)) SWIG_fail;
17921 }
17922 if (arg1) (arg1)->m_metaDown = arg2;
17923
17924 Py_INCREF(Py_None); resultobj = Py_None;
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17934 bool result;
17935 PyObject * obj0 = 0 ;
17936 char *kwnames[] = {
17937 (char *) "self", NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17942 if (SWIG_arg_fail(1)) SWIG_fail;
17943 result = (bool) ((arg1)->m_metaDown);
17944
17945 {
17946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17947 }
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj;
17956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17957 int arg2 ;
17958 PyObject * obj0 = 0 ;
17959 PyObject * obj1 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self",(char *) "m_wheelRotation", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 {
17968 arg2 = (int)(SWIG_As_int(obj1));
17969 if (SWIG_arg_fail(2)) SWIG_fail;
17970 }
17971 if (arg1) (arg1)->m_wheelRotation = arg2;
17972
17973 Py_INCREF(Py_None); resultobj = Py_None;
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj;
17982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17983 int result;
17984 PyObject * obj0 = 0 ;
17985 char *kwnames[] = {
17986 (char *) "self", NULL
17987 };
17988
17989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17991 if (SWIG_arg_fail(1)) SWIG_fail;
17992 result = (int) ((arg1)->m_wheelRotation);
17993
17994 {
17995 resultobj = SWIG_From_int((int)(result));
17996 }
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18004 PyObject *resultobj;
18005 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18006 int arg2 ;
18007 PyObject * obj0 = 0 ;
18008 PyObject * obj1 = 0 ;
18009 char *kwnames[] = {
18010 (char *) "self",(char *) "m_wheelDelta", NULL
18011 };
18012
18013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 {
18017 arg2 = (int)(SWIG_As_int(obj1));
18018 if (SWIG_arg_fail(2)) SWIG_fail;
18019 }
18020 if (arg1) (arg1)->m_wheelDelta = arg2;
18021
18022 Py_INCREF(Py_None); resultobj = Py_None;
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj;
18031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18032 int result;
18033 PyObject * obj0 = 0 ;
18034 char *kwnames[] = {
18035 (char *) "self", NULL
18036 };
18037
18038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18040 if (SWIG_arg_fail(1)) SWIG_fail;
18041 result = (int) ((arg1)->m_wheelDelta);
18042
18043 {
18044 resultobj = SWIG_From_int((int)(result));
18045 }
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18053 PyObject *resultobj;
18054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18055 int arg2 ;
18056 PyObject * obj0 = 0 ;
18057 PyObject * obj1 = 0 ;
18058 char *kwnames[] = {
18059 (char *) "self",(char *) "m_linesPerAction", NULL
18060 };
18061
18062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18064 if (SWIG_arg_fail(1)) SWIG_fail;
18065 {
18066 arg2 = (int)(SWIG_As_int(obj1));
18067 if (SWIG_arg_fail(2)) SWIG_fail;
18068 }
18069 if (arg1) (arg1)->m_linesPerAction = arg2;
18070
18071 Py_INCREF(Py_None); resultobj = Py_None;
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj;
18080 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18081 int result;
18082 PyObject * obj0 = 0 ;
18083 char *kwnames[] = {
18084 (char *) "self", NULL
18085 };
18086
18087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18089 if (SWIG_arg_fail(1)) SWIG_fail;
18090 result = (int) ((arg1)->m_linesPerAction);
18091
18092 {
18093 resultobj = SWIG_From_int((int)(result));
18094 }
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18102 PyObject *obj;
18103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18104 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18105 Py_INCREF(obj);
18106 return Py_BuildValue((char *)"");
18107 }
18108 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 int arg1 = (int) 0 ;
18111 int arg2 = (int) 0 ;
18112 wxSetCursorEvent *result;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 char *kwnames[] = {
18116 (char *) "x",(char *) "y", NULL
18117 };
18118
18119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18120 if (obj0) {
18121 {
18122 arg1 = (int)(SWIG_As_int(obj0));
18123 if (SWIG_arg_fail(1)) SWIG_fail;
18124 }
18125 }
18126 if (obj1) {
18127 {
18128 arg2 = (int)(SWIG_As_int(obj1));
18129 if (SWIG_arg_fail(2)) SWIG_fail;
18130 }
18131 }
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18135
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj;
18148 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18149 int result;
18150 PyObject * obj0 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "self", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(1)) SWIG_fail;
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18161
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 {
18166 resultobj = SWIG_From_int((int)(result));
18167 }
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj;
18176 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 {
18194 resultobj = SWIG_From_int((int)(result));
18195 }
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj;
18204 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18205 wxCursor *arg2 = 0 ;
18206 PyObject * obj0 = 0 ;
18207 PyObject * obj1 = 0 ;
18208 char *kwnames[] = {
18209 (char *) "self",(char *) "cursor", NULL
18210 };
18211
18212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18214 if (SWIG_arg_fail(1)) SWIG_fail;
18215 {
18216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(2)) SWIG_fail;
18218 if (arg2 == NULL) {
18219 SWIG_null_ref("wxCursor");
18220 }
18221 if (SWIG_arg_fail(2)) SWIG_fail;
18222 }
18223 {
18224 PyThreadState* __tstate = wxPyBeginAllowThreads();
18225 (arg1)->SetCursor((wxCursor const &)*arg2);
18226
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 Py_INCREF(Py_None); resultobj = Py_None;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj;
18239 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18240 wxCursor *result;
18241 PyObject * obj0 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 {
18252 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18253 result = (wxCursor *) &_result_ref;
18254 }
18255
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 {
18260 wxCursor* resultptr = new wxCursor(*result);
18261 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18262 }
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj;
18271 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18272 bool result;
18273 PyObject * obj0 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18284
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 {
18289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18290 }
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18298 PyObject *obj;
18299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18300 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18301 Py_INCREF(obj);
18302 return Py_BuildValue((char *)"");
18303 }
18304 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj;
18306 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18307 wxKeyEvent *result;
18308 PyObject * obj0 = 0 ;
18309 char *kwnames[] = {
18310 (char *) "keyType", NULL
18311 };
18312
18313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18314 if (obj0) {
18315 {
18316 arg1 = (wxEventType)(SWIG_As_int(obj0));
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 }
18319 }
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18323
18324 wxPyEndAllowThreads(__tstate);
18325 if (PyErr_Occurred()) SWIG_fail;
18326 }
18327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 static PyObject *_wrap_KeyEvent_ControlDown(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_ControlDown",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)->ControlDown();
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_MetaDown(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_MetaDown",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)->MetaDown();
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_AltDown(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_AltDown",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)->AltDown();
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_ShiftDown(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_ShiftDown",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)->ShiftDown();
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_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18449 bool result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 bool result;
18478 PyObject * obj0 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18495 }
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18505 int result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",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 = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = SWIG_From_int((int)(result));
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18533 int result;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_int((int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18561 unsigned int result;
18562 PyObject * obj0 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "self", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",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 = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18589 unsigned int result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "self", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18597 if (SWIG_arg_fail(1)) SWIG_fail;
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18601
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 {
18606 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18607 }
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18617 wxPoint result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (arg1)->GetPosition();
18629
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 wxPoint * resultptr;
18635 resultptr = new wxPoint((wxPoint &)(result));
18636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18637 }
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18645 PyObject *resultobj;
18646 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18647 long *arg2 = (long *) 0 ;
18648 long *arg3 = (long *) 0 ;
18649 long temp2 ;
18650 int res2 = 0 ;
18651 long temp3 ;
18652 int res3 = 0 ;
18653 PyObject * obj0 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self", NULL
18656 };
18657
18658 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18659 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18662 if (SWIG_arg_fail(1)) SWIG_fail;
18663 {
18664 PyThreadState* __tstate = wxPyBeginAllowThreads();
18665 (arg1)->GetPosition(arg2,arg3);
18666
18667 wxPyEndAllowThreads(__tstate);
18668 if (PyErr_Occurred()) SWIG_fail;
18669 }
18670 Py_INCREF(Py_None); resultobj = Py_None;
18671 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18672 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18673 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18674 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18684 int result;
18685 PyObject * obj0 = 0 ;
18686 char *kwnames[] = {
18687 (char *) "self", NULL
18688 };
18689
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18692 if (SWIG_arg_fail(1)) SWIG_fail;
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 result = (int)((wxKeyEvent const *)arg1)->GetX();
18696
18697 wxPyEndAllowThreads(__tstate);
18698 if (PyErr_Occurred()) SWIG_fail;
18699 }
18700 {
18701 resultobj = SWIG_From_int((int)(result));
18702 }
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18712 int result;
18713 PyObject * obj0 = 0 ;
18714 char *kwnames[] = {
18715 (char *) "self", NULL
18716 };
18717
18718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18720 if (SWIG_arg_fail(1)) SWIG_fail;
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (int)((wxKeyEvent const *)arg1)->GetY();
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 {
18729 resultobj = SWIG_From_int((int)(result));
18730 }
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18740 int arg2 ;
18741 PyObject * obj0 = 0 ;
18742 PyObject * obj1 = 0 ;
18743 char *kwnames[] = {
18744 (char *) "self",(char *) "m_x", NULL
18745 };
18746
18747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18749 if (SWIG_arg_fail(1)) SWIG_fail;
18750 {
18751 arg2 = (int)(SWIG_As_int(obj1));
18752 if (SWIG_arg_fail(2)) SWIG_fail;
18753 }
18754 if (arg1) (arg1)->m_x = arg2;
18755
18756 Py_INCREF(Py_None); resultobj = Py_None;
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj;
18765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18766 int result;
18767 PyObject * obj0 = 0 ;
18768 char *kwnames[] = {
18769 (char *) "self", NULL
18770 };
18771
18772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18774 if (SWIG_arg_fail(1)) SWIG_fail;
18775 result = (int) ((arg1)->m_x);
18776
18777 {
18778 resultobj = SWIG_From_int((int)(result));
18779 }
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj;
18788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18789 int arg2 ;
18790 PyObject * obj0 = 0 ;
18791 PyObject * obj1 = 0 ;
18792 char *kwnames[] = {
18793 (char *) "self",(char *) "m_y", NULL
18794 };
18795
18796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18798 if (SWIG_arg_fail(1)) SWIG_fail;
18799 {
18800 arg2 = (int)(SWIG_As_int(obj1));
18801 if (SWIG_arg_fail(2)) SWIG_fail;
18802 }
18803 if (arg1) (arg1)->m_y = arg2;
18804
18805 Py_INCREF(Py_None); resultobj = Py_None;
18806 return resultobj;
18807 fail:
18808 return NULL;
18809 }
18810
18811
18812 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj;
18814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18815 int result;
18816 PyObject * obj0 = 0 ;
18817 char *kwnames[] = {
18818 (char *) "self", NULL
18819 };
18820
18821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18823 if (SWIG_arg_fail(1)) SWIG_fail;
18824 result = (int) ((arg1)->m_y);
18825
18826 {
18827 resultobj = SWIG_From_int((int)(result));
18828 }
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18836 PyObject *resultobj;
18837 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18838 long arg2 ;
18839 PyObject * obj0 = 0 ;
18840 PyObject * obj1 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "self",(char *) "m_keyCode", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18847 if (SWIG_arg_fail(1)) SWIG_fail;
18848 {
18849 arg2 = (long)(SWIG_As_long(obj1));
18850 if (SWIG_arg_fail(2)) SWIG_fail;
18851 }
18852 if (arg1) (arg1)->m_keyCode = arg2;
18853
18854 Py_INCREF(Py_None); resultobj = Py_None;
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj;
18863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18864 long result;
18865 PyObject * obj0 = 0 ;
18866 char *kwnames[] = {
18867 (char *) "self", NULL
18868 };
18869
18870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18872 if (SWIG_arg_fail(1)) SWIG_fail;
18873 result = (long) ((arg1)->m_keyCode);
18874
18875 {
18876 resultobj = SWIG_From_long((long)(result));
18877 }
18878 return resultobj;
18879 fail:
18880 return NULL;
18881 }
18882
18883
18884 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18885 PyObject *resultobj;
18886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18887 bool arg2 ;
18888 PyObject * obj0 = 0 ;
18889 PyObject * obj1 = 0 ;
18890 char *kwnames[] = {
18891 (char *) "self",(char *) "m_controlDown", NULL
18892 };
18893
18894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18896 if (SWIG_arg_fail(1)) SWIG_fail;
18897 {
18898 arg2 = (bool)(SWIG_As_bool(obj1));
18899 if (SWIG_arg_fail(2)) SWIG_fail;
18900 }
18901 if (arg1) (arg1)->m_controlDown = arg2;
18902
18903 Py_INCREF(Py_None); resultobj = Py_None;
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj;
18912 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18913 bool result;
18914 PyObject * obj0 = 0 ;
18915 char *kwnames[] = {
18916 (char *) "self", NULL
18917 };
18918
18919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18921 if (SWIG_arg_fail(1)) SWIG_fail;
18922 result = (bool) ((arg1)->m_controlDown);
18923
18924 {
18925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18926 }
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18934 PyObject *resultobj;
18935 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18936 bool arg2 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char *kwnames[] = {
18940 (char *) "self",(char *) "m_shiftDown", NULL
18941 };
18942
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 {
18947 arg2 = (bool)(SWIG_As_bool(obj1));
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 }
18950 if (arg1) (arg1)->m_shiftDown = arg2;
18951
18952 Py_INCREF(Py_None); resultobj = Py_None;
18953 return resultobj;
18954 fail:
18955 return NULL;
18956 }
18957
18958
18959 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18960 PyObject *resultobj;
18961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18962 bool result;
18963 PyObject * obj0 = 0 ;
18964 char *kwnames[] = {
18965 (char *) "self", NULL
18966 };
18967
18968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18970 if (SWIG_arg_fail(1)) SWIG_fail;
18971 result = (bool) ((arg1)->m_shiftDown);
18972
18973 {
18974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18975 }
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj;
18984 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18985 bool arg2 ;
18986 PyObject * obj0 = 0 ;
18987 PyObject * obj1 = 0 ;
18988 char *kwnames[] = {
18989 (char *) "self",(char *) "m_altDown", NULL
18990 };
18991
18992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18994 if (SWIG_arg_fail(1)) SWIG_fail;
18995 {
18996 arg2 = (bool)(SWIG_As_bool(obj1));
18997 if (SWIG_arg_fail(2)) SWIG_fail;
18998 }
18999 if (arg1) (arg1)->m_altDown = arg2;
19000
19001 Py_INCREF(Py_None); resultobj = Py_None;
19002 return resultobj;
19003 fail:
19004 return NULL;
19005 }
19006
19007
19008 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19009 PyObject *resultobj;
19010 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19011 bool result;
19012 PyObject * obj0 = 0 ;
19013 char *kwnames[] = {
19014 (char *) "self", NULL
19015 };
19016
19017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19019 if (SWIG_arg_fail(1)) SWIG_fail;
19020 result = (bool) ((arg1)->m_altDown);
19021
19022 {
19023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19024 }
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19034 bool arg2 ;
19035 PyObject * obj0 = 0 ;
19036 PyObject * obj1 = 0 ;
19037 char *kwnames[] = {
19038 (char *) "self",(char *) "m_metaDown", NULL
19039 };
19040
19041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 {
19045 arg2 = (bool)(SWIG_As_bool(obj1));
19046 if (SWIG_arg_fail(2)) SWIG_fail;
19047 }
19048 if (arg1) (arg1)->m_metaDown = arg2;
19049
19050 Py_INCREF(Py_None); resultobj = Py_None;
19051 return resultobj;
19052 fail:
19053 return NULL;
19054 }
19055
19056
19057 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19058 PyObject *resultobj;
19059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19060 bool result;
19061 PyObject * obj0 = 0 ;
19062 char *kwnames[] = {
19063 (char *) "self", NULL
19064 };
19065
19066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19068 if (SWIG_arg_fail(1)) SWIG_fail;
19069 result = (bool) ((arg1)->m_metaDown);
19070
19071 {
19072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19073 }
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19083 bool arg2 ;
19084 PyObject * obj0 = 0 ;
19085 PyObject * obj1 = 0 ;
19086 char *kwnames[] = {
19087 (char *) "self",(char *) "m_scanCode", NULL
19088 };
19089
19090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 {
19094 arg2 = (bool)(SWIG_As_bool(obj1));
19095 if (SWIG_arg_fail(2)) SWIG_fail;
19096 }
19097 if (arg1) (arg1)->m_scanCode = arg2;
19098
19099 Py_INCREF(Py_None); resultobj = Py_None;
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19109 bool result;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 result = (bool) ((arg1)->m_scanCode);
19119
19120 {
19121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19122 }
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19130 PyObject *resultobj;
19131 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19132 unsigned int arg2 ;
19133 PyObject * obj0 = 0 ;
19134 PyObject * obj1 = 0 ;
19135 char *kwnames[] = {
19136 (char *) "self",(char *) "m_rawCode", NULL
19137 };
19138
19139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19141 if (SWIG_arg_fail(1)) SWIG_fail;
19142 {
19143 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19144 if (SWIG_arg_fail(2)) SWIG_fail;
19145 }
19146 if (arg1) (arg1)->m_rawCode = arg2;
19147
19148 Py_INCREF(Py_None); resultobj = Py_None;
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj;
19157 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19158 unsigned int result;
19159 PyObject * obj0 = 0 ;
19160 char *kwnames[] = {
19161 (char *) "self", NULL
19162 };
19163
19164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19166 if (SWIG_arg_fail(1)) SWIG_fail;
19167 result = (unsigned int) ((arg1)->m_rawCode);
19168
19169 {
19170 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19171 }
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj;
19180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19181 unsigned int arg2 ;
19182 PyObject * obj0 = 0 ;
19183 PyObject * obj1 = 0 ;
19184 char *kwnames[] = {
19185 (char *) "self",(char *) "m_rawFlags", NULL
19186 };
19187
19188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19190 if (SWIG_arg_fail(1)) SWIG_fail;
19191 {
19192 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 }
19195 if (arg1) (arg1)->m_rawFlags = arg2;
19196
19197 Py_INCREF(Py_None); resultobj = Py_None;
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19205 PyObject *resultobj;
19206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19207 unsigned int result;
19208 PyObject * obj0 = 0 ;
19209 char *kwnames[] = {
19210 (char *) "self", NULL
19211 };
19212
19213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19215 if (SWIG_arg_fail(1)) SWIG_fail;
19216 result = (unsigned int) ((arg1)->m_rawFlags);
19217
19218 {
19219 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19220 }
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19228 PyObject *obj;
19229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19230 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19231 Py_INCREF(obj);
19232 return Py_BuildValue((char *)"");
19233 }
19234 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19235 PyObject *resultobj;
19236 wxSize const &arg1_defvalue = wxDefaultSize ;
19237 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19238 int arg2 = (int) 0 ;
19239 wxSizeEvent *result;
19240 wxSize temp1 ;
19241 PyObject * obj0 = 0 ;
19242 PyObject * obj1 = 0 ;
19243 char *kwnames[] = {
19244 (char *) "sz",(char *) "winid", NULL
19245 };
19246
19247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19248 if (obj0) {
19249 {
19250 arg1 = &temp1;
19251 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19252 }
19253 }
19254 if (obj1) {
19255 {
19256 arg2 = (int)(SWIG_As_int(obj1));
19257 if (SWIG_arg_fail(2)) SWIG_fail;
19258 }
19259 }
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19263
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19277 wxSize result;
19278 PyObject * obj0 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "self", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19285 if (SWIG_arg_fail(1)) SWIG_fail;
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = ((wxSizeEvent const *)arg1)->GetSize();
19289
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 {
19294 wxSize * resultptr;
19295 resultptr = new wxSize((wxSize &)(result));
19296 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19297 }
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19305 PyObject *resultobj;
19306 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19307 wxRect result;
19308 PyObject * obj0 = 0 ;
19309 char *kwnames[] = {
19310 (char *) "self", NULL
19311 };
19312
19313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19315 if (SWIG_arg_fail(1)) SWIG_fail;
19316 {
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = ((wxSizeEvent const *)arg1)->GetRect();
19319
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 {
19324 wxRect * resultptr;
19325 resultptr = new wxRect((wxRect &)(result));
19326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19327 }
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19335 PyObject *resultobj;
19336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19337 wxRect arg2 ;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char *kwnames[] = {
19341 (char *) "self",(char *) "rect", NULL
19342 };
19343
19344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19346 if (SWIG_arg_fail(1)) SWIG_fail;
19347 {
19348 wxRect * argp;
19349 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19350 if (SWIG_arg_fail(2)) SWIG_fail;
19351 if (argp == NULL) {
19352 SWIG_null_ref("wxRect");
19353 }
19354 if (SWIG_arg_fail(2)) SWIG_fail;
19355 arg2 = *argp;
19356 }
19357 {
19358 PyThreadState* __tstate = wxPyBeginAllowThreads();
19359 (arg1)->SetRect(arg2);
19360
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 Py_INCREF(Py_None); resultobj = Py_None;
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19372 PyObject *resultobj;
19373 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19374 wxSize arg2 ;
19375 PyObject * obj0 = 0 ;
19376 PyObject * obj1 = 0 ;
19377 char *kwnames[] = {
19378 (char *) "self",(char *) "size", NULL
19379 };
19380
19381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19383 if (SWIG_arg_fail(1)) SWIG_fail;
19384 {
19385 wxSize * argp;
19386 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19387 if (SWIG_arg_fail(2)) SWIG_fail;
19388 if (argp == NULL) {
19389 SWIG_null_ref("wxSize");
19390 }
19391 if (SWIG_arg_fail(2)) SWIG_fail;
19392 arg2 = *argp;
19393 }
19394 {
19395 PyThreadState* __tstate = wxPyBeginAllowThreads();
19396 wxSizeEvent_SetSize(arg1,arg2);
19397
19398 wxPyEndAllowThreads(__tstate);
19399 if (PyErr_Occurred()) SWIG_fail;
19400 }
19401 Py_INCREF(Py_None); resultobj = Py_None;
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj;
19410 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19411 wxSize *arg2 = (wxSize *) 0 ;
19412 PyObject * obj0 = 0 ;
19413 PyObject * obj1 = 0 ;
19414 char *kwnames[] = {
19415 (char *) "self",(char *) "m_size", NULL
19416 };
19417
19418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19420 if (SWIG_arg_fail(1)) SWIG_fail;
19421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19422 if (SWIG_arg_fail(2)) SWIG_fail;
19423 if (arg1) (arg1)->m_size = *arg2;
19424
19425 Py_INCREF(Py_None); resultobj = Py_None;
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19435 wxSize *result;
19436 PyObject * obj0 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "self", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19443 if (SWIG_arg_fail(1)) SWIG_fail;
19444 result = (wxSize *)& ((arg1)->m_size);
19445
19446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj;
19455 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19456 wxRect *arg2 = (wxRect *) 0 ;
19457 PyObject * obj0 = 0 ;
19458 PyObject * obj1 = 0 ;
19459 char *kwnames[] = {
19460 (char *) "self",(char *) "m_rect", NULL
19461 };
19462
19463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19465 if (SWIG_arg_fail(1)) SWIG_fail;
19466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19467 if (SWIG_arg_fail(2)) SWIG_fail;
19468 if (arg1) (arg1)->m_rect = *arg2;
19469
19470 Py_INCREF(Py_None); resultobj = Py_None;
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19478 PyObject *resultobj;
19479 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19480 wxRect *result;
19481 PyObject * obj0 = 0 ;
19482 char *kwnames[] = {
19483 (char *) "self", NULL
19484 };
19485
19486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19488 if (SWIG_arg_fail(1)) SWIG_fail;
19489 result = (wxRect *)& ((arg1)->m_rect);
19490
19491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19499 PyObject *obj;
19500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19501 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19502 Py_INCREF(obj);
19503 return Py_BuildValue((char *)"");
19504 }
19505 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19508 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19509 int arg2 = (int) 0 ;
19510 wxMoveEvent *result;
19511 wxPoint temp1 ;
19512 PyObject * obj0 = 0 ;
19513 PyObject * obj1 = 0 ;
19514 char *kwnames[] = {
19515 (char *) "pos",(char *) "winid", NULL
19516 };
19517
19518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19519 if (obj0) {
19520 {
19521 arg1 = &temp1;
19522 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19523 }
19524 }
19525 if (obj1) {
19526 {
19527 arg2 = (int)(SWIG_As_int(obj1));
19528 if (SWIG_arg_fail(2)) SWIG_fail;
19529 }
19530 }
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19534
19535 wxPyEndAllowThreads(__tstate);
19536 if (PyErr_Occurred()) SWIG_fail;
19537 }
19538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19539 return resultobj;
19540 fail:
19541 return NULL;
19542 }
19543
19544
19545 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19546 PyObject *resultobj;
19547 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19548 wxPoint result;
19549 PyObject * obj0 = 0 ;
19550 char *kwnames[] = {
19551 (char *) "self", NULL
19552 };
19553
19554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19556 if (SWIG_arg_fail(1)) SWIG_fail;
19557 {
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = ((wxMoveEvent const *)arg1)->GetPosition();
19560
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 {
19565 wxPoint * resultptr;
19566 resultptr = new wxPoint((wxPoint &)(result));
19567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19568 }
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19576 PyObject *resultobj;
19577 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19578 wxRect result;
19579 PyObject * obj0 = 0 ;
19580 char *kwnames[] = {
19581 (char *) "self", NULL
19582 };
19583
19584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19586 if (SWIG_arg_fail(1)) SWIG_fail;
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 result = ((wxMoveEvent const *)arg1)->GetRect();
19590
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 {
19595 wxRect * resultptr;
19596 resultptr = new wxRect((wxRect &)(result));
19597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19598 }
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj;
19607 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19608 wxRect *arg2 = 0 ;
19609 wxRect temp2 ;
19610 PyObject * obj0 = 0 ;
19611 PyObject * obj1 = 0 ;
19612 char *kwnames[] = {
19613 (char *) "self",(char *) "rect", NULL
19614 };
19615
19616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19618 if (SWIG_arg_fail(1)) SWIG_fail;
19619 {
19620 arg2 = &temp2;
19621 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19622 }
19623 {
19624 PyThreadState* __tstate = wxPyBeginAllowThreads();
19625 (arg1)->SetRect((wxRect const &)*arg2);
19626
19627 wxPyEndAllowThreads(__tstate);
19628 if (PyErr_Occurred()) SWIG_fail;
19629 }
19630 Py_INCREF(Py_None); resultobj = Py_None;
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19638 PyObject *resultobj;
19639 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19640 wxPoint *arg2 = 0 ;
19641 wxPoint temp2 ;
19642 PyObject * obj0 = 0 ;
19643 PyObject * obj1 = 0 ;
19644 char *kwnames[] = {
19645 (char *) "self",(char *) "pos", NULL
19646 };
19647
19648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19650 if (SWIG_arg_fail(1)) SWIG_fail;
19651 {
19652 arg2 = &temp2;
19653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19654 }
19655 {
19656 PyThreadState* __tstate = wxPyBeginAllowThreads();
19657 (arg1)->SetPosition((wxPoint const &)*arg2);
19658
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 Py_INCREF(Py_None); resultobj = Py_None;
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19670 PyObject *obj;
19671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19672 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19673 Py_INCREF(obj);
19674 return Py_BuildValue((char *)"");
19675 }
19676 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19677 PyObject *resultobj;
19678 int arg1 = (int) 0 ;
19679 wxPaintEvent *result;
19680 PyObject * obj0 = 0 ;
19681 char *kwnames[] = {
19682 (char *) "Id", NULL
19683 };
19684
19685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19686 if (obj0) {
19687 {
19688 arg1 = (int)(SWIG_As_int(obj0));
19689 if (SWIG_arg_fail(1)) SWIG_fail;
19690 }
19691 }
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19695
19696 wxPyEndAllowThreads(__tstate);
19697 if (PyErr_Occurred()) SWIG_fail;
19698 }
19699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19700 return resultobj;
19701 fail:
19702 return NULL;
19703 }
19704
19705
19706 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19707 PyObject *obj;
19708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19709 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19710 Py_INCREF(obj);
19711 return Py_BuildValue((char *)"");
19712 }
19713 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19714 PyObject *resultobj;
19715 int arg1 = (int) 0 ;
19716 wxNcPaintEvent *result;
19717 PyObject * obj0 = 0 ;
19718 char *kwnames[] = {
19719 (char *) "winid", NULL
19720 };
19721
19722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19723 if (obj0) {
19724 {
19725 arg1 = (int)(SWIG_As_int(obj0));
19726 if (SWIG_arg_fail(1)) SWIG_fail;
19727 }
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19732
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19737 return resultobj;
19738 fail:
19739 return NULL;
19740 }
19741
19742
19743 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19744 PyObject *obj;
19745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19746 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19747 Py_INCREF(obj);
19748 return Py_BuildValue((char *)"");
19749 }
19750 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19751 PyObject *resultobj;
19752 int arg1 = (int) 0 ;
19753 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19754 wxEraseEvent *result;
19755 PyObject * obj0 = 0 ;
19756 PyObject * obj1 = 0 ;
19757 char *kwnames[] = {
19758 (char *) "Id",(char *) "dc", NULL
19759 };
19760
19761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19762 if (obj0) {
19763 {
19764 arg1 = (int)(SWIG_As_int(obj0));
19765 if (SWIG_arg_fail(1)) SWIG_fail;
19766 }
19767 }
19768 if (obj1) {
19769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19770 if (SWIG_arg_fail(2)) SWIG_fail;
19771 }
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19775
19776 wxPyEndAllowThreads(__tstate);
19777 if (PyErr_Occurred()) SWIG_fail;
19778 }
19779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19780 return resultobj;
19781 fail:
19782 return NULL;
19783 }
19784
19785
19786 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19787 PyObject *resultobj;
19788 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19789 wxDC *result;
19790 PyObject * obj0 = 0 ;
19791 char *kwnames[] = {
19792 (char *) "self", NULL
19793 };
19794
19795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19797 if (SWIG_arg_fail(1)) SWIG_fail;
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19801
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = wxPyMake_wxObject(result, 0);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19815 PyObject *obj;
19816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19817 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19818 Py_INCREF(obj);
19819 return Py_BuildValue((char *)"");
19820 }
19821 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj;
19823 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19824 int arg2 = (int) 0 ;
19825 wxFocusEvent *result;
19826 PyObject * obj0 = 0 ;
19827 PyObject * obj1 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "type",(char *) "winid", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19833 if (obj0) {
19834 {
19835 arg1 = (wxEventType)(SWIG_As_int(obj0));
19836 if (SWIG_arg_fail(1)) SWIG_fail;
19837 }
19838 }
19839 if (obj1) {
19840 {
19841 arg2 = (int)(SWIG_As_int(obj1));
19842 if (SWIG_arg_fail(2)) SWIG_fail;
19843 }
19844 }
19845 {
19846 PyThreadState* __tstate = wxPyBeginAllowThreads();
19847 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19848
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj;
19861 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19862 wxWindow *result;
19863 PyObject * obj0 = 0 ;
19864 char *kwnames[] = {
19865 (char *) "self", NULL
19866 };
19867
19868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19870 if (SWIG_arg_fail(1)) SWIG_fail;
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 {
19879 resultobj = wxPyMake_wxObject(result, 0);
19880 }
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19890 wxWindow *arg2 = (wxWindow *) 0 ;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 char *kwnames[] = {
19894 (char *) "self",(char *) "win", NULL
19895 };
19896
19897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19899 if (SWIG_arg_fail(1)) SWIG_fail;
19900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19901 if (SWIG_arg_fail(2)) SWIG_fail;
19902 {
19903 PyThreadState* __tstate = wxPyBeginAllowThreads();
19904 (arg1)->SetWindow(arg2);
19905
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 Py_INCREF(Py_None); resultobj = Py_None;
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19917 PyObject *obj;
19918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19919 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19920 Py_INCREF(obj);
19921 return Py_BuildValue((char *)"");
19922 }
19923 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19924 PyObject *resultobj;
19925 wxWindow *arg1 = (wxWindow *) NULL ;
19926 wxChildFocusEvent *result;
19927 PyObject * obj0 = 0 ;
19928 char *kwnames[] = {
19929 (char *) "win", NULL
19930 };
19931
19932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19933 if (obj0) {
19934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19935 if (SWIG_arg_fail(1)) SWIG_fail;
19936 }
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19940
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19954 wxWindow *result;
19955 PyObject * obj0 = 0 ;
19956 char *kwnames[] = {
19957 (char *) "self", NULL
19958 };
19959
19960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19962 if (SWIG_arg_fail(1)) SWIG_fail;
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19966
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 {
19971 resultobj = wxPyMake_wxObject(result, 0);
19972 }
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19980 PyObject *obj;
19981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19982 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19983 Py_INCREF(obj);
19984 return Py_BuildValue((char *)"");
19985 }
19986 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19987 PyObject *resultobj;
19988 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19989 bool arg2 = (bool) true ;
19990 int arg3 = (int) 0 ;
19991 wxActivateEvent *result;
19992 PyObject * obj0 = 0 ;
19993 PyObject * obj1 = 0 ;
19994 PyObject * obj2 = 0 ;
19995 char *kwnames[] = {
19996 (char *) "type",(char *) "active",(char *) "Id", NULL
19997 };
19998
19999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20000 if (obj0) {
20001 {
20002 arg1 = (wxEventType)(SWIG_As_int(obj0));
20003 if (SWIG_arg_fail(1)) SWIG_fail;
20004 }
20005 }
20006 if (obj1) {
20007 {
20008 arg2 = (bool)(SWIG_As_bool(obj1));
20009 if (SWIG_arg_fail(2)) SWIG_fail;
20010 }
20011 }
20012 if (obj2) {
20013 {
20014 arg3 = (int)(SWIG_As_int(obj2));
20015 if (SWIG_arg_fail(3)) SWIG_fail;
20016 }
20017 }
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20021
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20035 bool result;
20036 PyObject * obj0 = 0 ;
20037 char *kwnames[] = {
20038 (char *) "self", NULL
20039 };
20040
20041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20043 if (SWIG_arg_fail(1)) SWIG_fail;
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 {
20052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20053 }
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20061 PyObject *obj;
20062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20063 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20064 Py_INCREF(obj);
20065 return Py_BuildValue((char *)"");
20066 }
20067 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 int arg1 = (int) 0 ;
20070 wxInitDialogEvent *result;
20071 PyObject * obj0 = 0 ;
20072 char *kwnames[] = {
20073 (char *) "Id", NULL
20074 };
20075
20076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20077 if (obj0) {
20078 {
20079 arg1 = (int)(SWIG_As_int(obj0));
20080 if (SWIG_arg_fail(1)) SWIG_fail;
20081 }
20082 }
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20086
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20098 PyObject *obj;
20099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20100 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20101 Py_INCREF(obj);
20102 return Py_BuildValue((char *)"");
20103 }
20104 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20105 PyObject *resultobj;
20106 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20107 int arg2 = (int) 0 ;
20108 wxMenu *arg3 = (wxMenu *) NULL ;
20109 wxMenuEvent *result;
20110 PyObject * obj0 = 0 ;
20111 PyObject * obj1 = 0 ;
20112 PyObject * obj2 = 0 ;
20113 char *kwnames[] = {
20114 (char *) "type",(char *) "winid",(char *) "menu", NULL
20115 };
20116
20117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20118 if (obj0) {
20119 {
20120 arg1 = (wxEventType)(SWIG_As_int(obj0));
20121 if (SWIG_arg_fail(1)) SWIG_fail;
20122 }
20123 }
20124 if (obj1) {
20125 {
20126 arg2 = (int)(SWIG_As_int(obj1));
20127 if (SWIG_arg_fail(2)) SWIG_fail;
20128 }
20129 }
20130 if (obj2) {
20131 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20132 if (SWIG_arg_fail(3)) SWIG_fail;
20133 }
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20137
20138 wxPyEndAllowThreads(__tstate);
20139 if (PyErr_Occurred()) SWIG_fail;
20140 }
20141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20142 return resultobj;
20143 fail:
20144 return NULL;
20145 }
20146
20147
20148 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20149 PyObject *resultobj;
20150 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20151 int result;
20152 PyObject * obj0 = 0 ;
20153 char *kwnames[] = {
20154 (char *) "self", NULL
20155 };
20156
20157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",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 = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = SWIG_From_int((int)(result));
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20179 bool result;
20180 PyObject * obj0 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20207 wxMenu *result;
20208 PyObject * obj0 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = wxPyMake_wxObject(result, 0);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20233 PyObject *obj;
20234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20235 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20236 Py_INCREF(obj);
20237 return Py_BuildValue((char *)"");
20238 }
20239 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20242 int arg2 = (int) 0 ;
20243 wxCloseEvent *result;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "type",(char *) "winid", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20251 if (obj0) {
20252 {
20253 arg1 = (wxEventType)(SWIG_As_int(obj0));
20254 if (SWIG_arg_fail(1)) SWIG_fail;
20255 }
20256 }
20257 if (obj1) {
20258 {
20259 arg2 = (int)(SWIG_As_int(obj1));
20260 if (SWIG_arg_fail(2)) SWIG_fail;
20261 }
20262 }
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20266
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20278 PyObject *resultobj;
20279 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20280 bool arg2 ;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char *kwnames[] = {
20284 (char *) "self",(char *) "logOff", NULL
20285 };
20286
20287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20289 if (SWIG_arg_fail(1)) SWIG_fail;
20290 {
20291 arg2 = (bool)(SWIG_As_bool(obj1));
20292 if (SWIG_arg_fail(2)) SWIG_fail;
20293 }
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 (arg1)->SetLoggingOff(arg2);
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 Py_INCREF(Py_None); resultobj = Py_None;
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20311 bool result;
20312 PyObject * obj0 = 0 ;
20313 char *kwnames[] = {
20314 (char *) "self", NULL
20315 };
20316
20317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20319 if (SWIG_arg_fail(1)) SWIG_fail;
20320 {
20321 PyThreadState* __tstate = wxPyBeginAllowThreads();
20322 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20323
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj;
20338 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20339 bool arg2 = (bool) true ;
20340 PyObject * obj0 = 0 ;
20341 PyObject * obj1 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self",(char *) "veto", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 if (obj1) {
20350 {
20351 arg2 = (bool)(SWIG_As_bool(obj1));
20352 if (SWIG_arg_fail(2)) SWIG_fail;
20353 }
20354 }
20355 {
20356 PyThreadState* __tstate = wxPyBeginAllowThreads();
20357 (arg1)->Veto(arg2);
20358
20359 wxPyEndAllowThreads(__tstate);
20360 if (PyErr_Occurred()) SWIG_fail;
20361 }
20362 Py_INCREF(Py_None); resultobj = Py_None;
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj;
20371 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20372 bool arg2 ;
20373 PyObject * obj0 = 0 ;
20374 PyObject * obj1 = 0 ;
20375 char *kwnames[] = {
20376 (char *) "self",(char *) "canVeto", NULL
20377 };
20378
20379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20381 if (SWIG_arg_fail(1)) SWIG_fail;
20382 {
20383 arg2 = (bool)(SWIG_As_bool(obj1));
20384 if (SWIG_arg_fail(2)) SWIG_fail;
20385 }
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 (arg1)->SetCanVeto(arg2);
20389
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 Py_INCREF(Py_None); resultobj = Py_None;
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20403 bool result;
20404 PyObject * obj0 = 0 ;
20405 char *kwnames[] = {
20406 (char *) "self", NULL
20407 };
20408
20409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20415
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 {
20420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20431 bool result;
20432 PyObject * obj0 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(1)) SWIG_fail;
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20457 PyObject *obj;
20458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20459 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20460 Py_INCREF(obj);
20461 return Py_BuildValue((char *)"");
20462 }
20463 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 int arg1 = (int) 0 ;
20466 bool arg2 = (bool) false ;
20467 wxShowEvent *result;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 char *kwnames[] = {
20471 (char *) "winid",(char *) "show", NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20475 if (obj0) {
20476 {
20477 arg1 = (int)(SWIG_As_int(obj0));
20478 if (SWIG_arg_fail(1)) SWIG_fail;
20479 }
20480 }
20481 if (obj1) {
20482 {
20483 arg2 = (bool)(SWIG_As_bool(obj1));
20484 if (SWIG_arg_fail(2)) SWIG_fail;
20485 }
20486 }
20487 {
20488 PyThreadState* __tstate = wxPyBeginAllowThreads();
20489 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20490
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20502 PyObject *resultobj;
20503 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20504 bool arg2 ;
20505 PyObject * obj0 = 0 ;
20506 PyObject * obj1 = 0 ;
20507 char *kwnames[] = {
20508 (char *) "self",(char *) "show", NULL
20509 };
20510
20511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20513 if (SWIG_arg_fail(1)) SWIG_fail;
20514 {
20515 arg2 = (bool)(SWIG_As_bool(obj1));
20516 if (SWIG_arg_fail(2)) SWIG_fail;
20517 }
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 (arg1)->SetShow(arg2);
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 Py_INCREF(Py_None); resultobj = Py_None;
20526 return resultobj;
20527 fail:
20528 return NULL;
20529 }
20530
20531
20532 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj;
20534 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20535 bool result;
20536 PyObject * obj0 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20547
20548 wxPyEndAllowThreads(__tstate);
20549 if (PyErr_Occurred()) SWIG_fail;
20550 }
20551 {
20552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20553 }
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20561 PyObject *obj;
20562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20563 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20564 Py_INCREF(obj);
20565 return Py_BuildValue((char *)"");
20566 }
20567 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 int arg1 = (int) 0 ;
20570 bool arg2 = (bool) true ;
20571 wxIconizeEvent *result;
20572 PyObject * obj0 = 0 ;
20573 PyObject * obj1 = 0 ;
20574 char *kwnames[] = {
20575 (char *) "id",(char *) "iconized", NULL
20576 };
20577
20578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20579 if (obj0) {
20580 {
20581 arg1 = (int)(SWIG_As_int(obj0));
20582 if (SWIG_arg_fail(1)) SWIG_fail;
20583 }
20584 }
20585 if (obj1) {
20586 {
20587 arg2 = (bool)(SWIG_As_bool(obj1));
20588 if (SWIG_arg_fail(2)) SWIG_fail;
20589 }
20590 }
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20594
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20599 return resultobj;
20600 fail:
20601 return NULL;
20602 }
20603
20604
20605 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20606 PyObject *resultobj;
20607 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20608 bool result;
20609 PyObject * obj0 = 0 ;
20610 char *kwnames[] = {
20611 (char *) "self", NULL
20612 };
20613
20614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20616 if (SWIG_arg_fail(1)) SWIG_fail;
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)(arg1)->Iconized();
20620
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20634 PyObject *obj;
20635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20636 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20637 Py_INCREF(obj);
20638 return Py_BuildValue((char *)"");
20639 }
20640 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20641 PyObject *resultobj;
20642 int arg1 = (int) 0 ;
20643 wxMaximizeEvent *result;
20644 PyObject * obj0 = 0 ;
20645 char *kwnames[] = {
20646 (char *) "id", NULL
20647 };
20648
20649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20650 if (obj0) {
20651 {
20652 arg1 = (int)(SWIG_As_int(obj0));
20653 if (SWIG_arg_fail(1)) SWIG_fail;
20654 }
20655 }
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20659
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20671 PyObject *obj;
20672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20673 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20674 Py_INCREF(obj);
20675 return Py_BuildValue((char *)"");
20676 }
20677 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj;
20679 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20680 wxPoint result;
20681 PyObject * obj0 = 0 ;
20682 char *kwnames[] = {
20683 (char *) "self", NULL
20684 };
20685
20686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20688 if (SWIG_arg_fail(1)) SWIG_fail;
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (arg1)->GetPosition();
20692
20693 wxPyEndAllowThreads(__tstate);
20694 if (PyErr_Occurred()) SWIG_fail;
20695 }
20696 {
20697 wxPoint * resultptr;
20698 resultptr = new wxPoint((wxPoint &)(result));
20699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20700 }
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20708 PyObject *resultobj;
20709 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20710 int result;
20711 PyObject * obj0 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "self", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (int)(arg1)->GetNumberOfFiles();
20722
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 resultobj = SWIG_From_int((int)(result));
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20738 PyObject *result;
20739 PyObject * obj0 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 resultobj = result;
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20762 PyObject *obj;
20763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20764 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20765 Py_INCREF(obj);
20766 return Py_BuildValue((char *)"");
20767 }
20768 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj;
20770 int arg1 = (int) 0 ;
20771 wxUpdateUIEvent *result;
20772 PyObject * obj0 = 0 ;
20773 char *kwnames[] = {
20774 (char *) "commandId", NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20778 if (obj0) {
20779 {
20780 arg1 = (int)(SWIG_As_int(obj0));
20781 if (SWIG_arg_fail(1)) SWIG_fail;
20782 }
20783 }
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20787
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20801 bool result;
20802 PyObject * obj0 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "self", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",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 = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 {
20818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20819 }
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20829 bool result;
20830 PyObject * obj0 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "self", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20837 if (SWIG_arg_fail(1)) SWIG_fail;
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj;
20856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20857 wxString result;
20858 PyObject * obj0 = 0 ;
20859 char *kwnames[] = {
20860 (char *) "self", NULL
20861 };
20862
20863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20865 if (SWIG_arg_fail(1)) SWIG_fail;
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20869
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 #if wxUSE_UNICODE
20875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20876 #else
20877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20878 #endif
20879 }
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 static PyObject *_wrap_UpdateUIEvent_GetSetText(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_GetSetText",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)->GetSetText();
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_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20917 bool result;
20918 PyObject * obj0 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "self", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20925 if (SWIG_arg_fail(1)) SWIG_fail;
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 {
20934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20945 bool result;
20946 PyObject * obj0 = 0 ;
20947 char *kwnames[] = {
20948 (char *) "self", NULL
20949 };
20950
20951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20953 if (SWIG_arg_fail(1)) SWIG_fail;
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20973 bool arg2 ;
20974 PyObject * obj0 = 0 ;
20975 PyObject * obj1 = 0 ;
20976 char *kwnames[] = {
20977 (char *) "self",(char *) "check", NULL
20978 };
20979
20980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20982 if (SWIG_arg_fail(1)) SWIG_fail;
20983 {
20984 arg2 = (bool)(SWIG_As_bool(obj1));
20985 if (SWIG_arg_fail(2)) SWIG_fail;
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 (arg1)->Check(arg2);
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 Py_INCREF(Py_None); resultobj = Py_None;
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21004 bool arg2 ;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 char *kwnames[] = {
21008 (char *) "self",(char *) "enable", NULL
21009 };
21010
21011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21013 if (SWIG_arg_fail(1)) SWIG_fail;
21014 {
21015 arg2 = (bool)(SWIG_As_bool(obj1));
21016 if (SWIG_arg_fail(2)) SWIG_fail;
21017 }
21018 {
21019 PyThreadState* __tstate = wxPyBeginAllowThreads();
21020 (arg1)->Enable(arg2);
21021
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 Py_INCREF(Py_None); resultobj = Py_None;
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21033 PyObject *resultobj;
21034 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21035 wxString *arg2 = 0 ;
21036 bool temp2 = false ;
21037 PyObject * obj0 = 0 ;
21038 PyObject * obj1 = 0 ;
21039 char *kwnames[] = {
21040 (char *) "self",(char *) "text", NULL
21041 };
21042
21043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21045 if (SWIG_arg_fail(1)) SWIG_fail;
21046 {
21047 arg2 = wxString_in_helper(obj1);
21048 if (arg2 == NULL) SWIG_fail;
21049 temp2 = true;
21050 }
21051 {
21052 PyThreadState* __tstate = wxPyBeginAllowThreads();
21053 (arg1)->SetText((wxString const &)*arg2);
21054
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 Py_INCREF(Py_None); resultobj = Py_None;
21059 {
21060 if (temp2)
21061 delete arg2;
21062 }
21063 return resultobj;
21064 fail:
21065 {
21066 if (temp2)
21067 delete arg2;
21068 }
21069 return NULL;
21070 }
21071
21072
21073 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21074 PyObject *resultobj;
21075 long arg1 ;
21076 PyObject * obj0 = 0 ;
21077 char *kwnames[] = {
21078 (char *) "updateInterval", NULL
21079 };
21080
21081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21082 {
21083 arg1 = (long)(SWIG_As_long(obj0));
21084 if (SWIG_arg_fail(1)) SWIG_fail;
21085 }
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 wxUpdateUIEvent::SetUpdateInterval(arg1);
21089
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 Py_INCREF(Py_None); resultobj = Py_None;
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21101 PyObject *resultobj;
21102 long result;
21103 char *kwnames[] = {
21104 NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21108 {
21109 PyThreadState* __tstate = wxPyBeginAllowThreads();
21110 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21111
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 {
21116 resultobj = SWIG_From_long((long)(result));
21117 }
21118 return resultobj;
21119 fail:
21120 return NULL;
21121 }
21122
21123
21124 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21125 PyObject *resultobj;
21126 wxWindow *arg1 = (wxWindow *) 0 ;
21127 bool result;
21128 PyObject * obj0 = 0 ;
21129 char *kwnames[] = {
21130 (char *) "win", NULL
21131 };
21132
21133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21135 if (SWIG_arg_fail(1)) SWIG_fail;
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 char *kwnames[] = {
21155 NULL
21156 };
21157
21158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 wxUpdateUIEvent::ResetUpdateTime();
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 Py_INCREF(Py_None); resultobj = Py_None;
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj;
21175 wxUpdateUIMode arg1 ;
21176 PyObject * obj0 = 0 ;
21177 char *kwnames[] = {
21178 (char *) "mode", NULL
21179 };
21180
21181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21182 {
21183 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21184 if (SWIG_arg_fail(1)) SWIG_fail;
21185 }
21186 {
21187 PyThreadState* __tstate = wxPyBeginAllowThreads();
21188 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21189
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 Py_INCREF(Py_None); resultobj = Py_None;
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21201 PyObject *resultobj;
21202 wxUpdateUIMode result;
21203 char *kwnames[] = {
21204 NULL
21205 };
21206
21207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21211
21212 wxPyEndAllowThreads(__tstate);
21213 if (PyErr_Occurred()) SWIG_fail;
21214 }
21215 resultobj = SWIG_From_int((result));
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21223 PyObject *obj;
21224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21225 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21226 Py_INCREF(obj);
21227 return Py_BuildValue((char *)"");
21228 }
21229 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21230 PyObject *resultobj;
21231 wxSysColourChangedEvent *result;
21232 char *kwnames[] = {
21233 NULL
21234 };
21235
21236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21252 PyObject *obj;
21253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21254 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21255 Py_INCREF(obj);
21256 return Py_BuildValue((char *)"");
21257 }
21258 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 int arg1 = (int) 0 ;
21261 wxWindow *arg2 = (wxWindow *) NULL ;
21262 wxMouseCaptureChangedEvent *result;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char *kwnames[] = {
21266 (char *) "winid",(char *) "gainedCapture", NULL
21267 };
21268
21269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21270 if (obj0) {
21271 {
21272 arg1 = (int)(SWIG_As_int(obj0));
21273 if (SWIG_arg_fail(1)) SWIG_fail;
21274 }
21275 }
21276 if (obj1) {
21277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21278 if (SWIG_arg_fail(2)) SWIG_fail;
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21283
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21288 return resultobj;
21289 fail:
21290 return NULL;
21291 }
21292
21293
21294 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21295 PyObject *resultobj;
21296 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21297 wxWindow *result;
21298 PyObject * obj0 = 0 ;
21299 char *kwnames[] = {
21300 (char *) "self", NULL
21301 };
21302
21303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21305 if (SWIG_arg_fail(1)) SWIG_fail;
21306 {
21307 PyThreadState* __tstate = wxPyBeginAllowThreads();
21308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21309
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 {
21314 resultobj = wxPyMake_wxObject(result, 0);
21315 }
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21323 PyObject *obj;
21324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21325 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21326 Py_INCREF(obj);
21327 return Py_BuildValue((char *)"");
21328 }
21329 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21330 PyObject *resultobj;
21331 wxDisplayChangedEvent *result;
21332 char *kwnames[] = {
21333 NULL
21334 };
21335
21336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21340
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21352 PyObject *obj;
21353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21354 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21355 Py_INCREF(obj);
21356 return Py_BuildValue((char *)"");
21357 }
21358 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21359 PyObject *resultobj;
21360 int arg1 = (int) 0 ;
21361 wxPaletteChangedEvent *result;
21362 PyObject * obj0 = 0 ;
21363 char *kwnames[] = {
21364 (char *) "id", NULL
21365 };
21366
21367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21368 if (obj0) {
21369 {
21370 arg1 = (int)(SWIG_As_int(obj0));
21371 if (SWIG_arg_fail(1)) SWIG_fail;
21372 }
21373 }
21374 {
21375 PyThreadState* __tstate = wxPyBeginAllowThreads();
21376 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21377
21378 wxPyEndAllowThreads(__tstate);
21379 if (PyErr_Occurred()) SWIG_fail;
21380 }
21381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21382 return resultobj;
21383 fail:
21384 return NULL;
21385 }
21386
21387
21388 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21391 wxWindow *arg2 = (wxWindow *) 0 ;
21392 PyObject * obj0 = 0 ;
21393 PyObject * obj1 = 0 ;
21394 char *kwnames[] = {
21395 (char *) "self",(char *) "win", NULL
21396 };
21397
21398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21400 if (SWIG_arg_fail(1)) SWIG_fail;
21401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21402 if (SWIG_arg_fail(2)) SWIG_fail;
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 (arg1)->SetChangedWindow(arg2);
21406
21407 wxPyEndAllowThreads(__tstate);
21408 if (PyErr_Occurred()) SWIG_fail;
21409 }
21410 Py_INCREF(Py_None); resultobj = Py_None;
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21418 PyObject *resultobj;
21419 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21420 wxWindow *result;
21421 PyObject * obj0 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 result = (wxWindow *)(arg1)->GetChangedWindow();
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 {
21437 resultobj = wxPyMake_wxObject(result, 0);
21438 }
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21446 PyObject *obj;
21447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21448 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21449 Py_INCREF(obj);
21450 return Py_BuildValue((char *)"");
21451 }
21452 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21453 PyObject *resultobj;
21454 int arg1 = (int) 0 ;
21455 wxQueryNewPaletteEvent *result;
21456 PyObject * obj0 = 0 ;
21457 char *kwnames[] = {
21458 (char *) "winid", NULL
21459 };
21460
21461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21462 if (obj0) {
21463 {
21464 arg1 = (int)(SWIG_As_int(obj0));
21465 if (SWIG_arg_fail(1)) SWIG_fail;
21466 }
21467 }
21468 {
21469 PyThreadState* __tstate = wxPyBeginAllowThreads();
21470 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21471
21472 wxPyEndAllowThreads(__tstate);
21473 if (PyErr_Occurred()) SWIG_fail;
21474 }
21475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21485 bool arg2 ;
21486 PyObject * obj0 = 0 ;
21487 PyObject * obj1 = 0 ;
21488 char *kwnames[] = {
21489 (char *) "self",(char *) "realized", NULL
21490 };
21491
21492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21494 if (SWIG_arg_fail(1)) SWIG_fail;
21495 {
21496 arg2 = (bool)(SWIG_As_bool(obj1));
21497 if (SWIG_arg_fail(2)) SWIG_fail;
21498 }
21499 {
21500 PyThreadState* __tstate = wxPyBeginAllowThreads();
21501 (arg1)->SetPaletteRealized(arg2);
21502
21503 wxPyEndAllowThreads(__tstate);
21504 if (PyErr_Occurred()) SWIG_fail;
21505 }
21506 Py_INCREF(Py_None); resultobj = Py_None;
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21514 PyObject *resultobj;
21515 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21516 bool result;
21517 PyObject * obj0 = 0 ;
21518 char *kwnames[] = {
21519 (char *) "self", NULL
21520 };
21521
21522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21524 if (SWIG_arg_fail(1)) SWIG_fail;
21525 {
21526 PyThreadState* __tstate = wxPyBeginAllowThreads();
21527 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21528
21529 wxPyEndAllowThreads(__tstate);
21530 if (PyErr_Occurred()) SWIG_fail;
21531 }
21532 {
21533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21534 }
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21542 PyObject *obj;
21543 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21544 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21545 Py_INCREF(obj);
21546 return Py_BuildValue((char *)"");
21547 }
21548 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21549 PyObject *resultobj;
21550 wxNavigationKeyEvent *result;
21551 char *kwnames[] = {
21552 NULL
21553 };
21554
21555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21556 {
21557 PyThreadState* __tstate = wxPyBeginAllowThreads();
21558 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21559
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21564 return resultobj;
21565 fail:
21566 return NULL;
21567 }
21568
21569
21570 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21571 PyObject *resultobj;
21572 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21573 bool result;
21574 PyObject * obj0 = 0 ;
21575 char *kwnames[] = {
21576 (char *) "self", NULL
21577 };
21578
21579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21581 if (SWIG_arg_fail(1)) SWIG_fail;
21582 {
21583 PyThreadState* __tstate = wxPyBeginAllowThreads();
21584 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21585
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 {
21590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21591 }
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21599 PyObject *resultobj;
21600 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21601 bool arg2 ;
21602 PyObject * obj0 = 0 ;
21603 PyObject * obj1 = 0 ;
21604 char *kwnames[] = {
21605 (char *) "self",(char *) "forward", NULL
21606 };
21607
21608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21610 if (SWIG_arg_fail(1)) SWIG_fail;
21611 {
21612 arg2 = (bool)(SWIG_As_bool(obj1));
21613 if (SWIG_arg_fail(2)) SWIG_fail;
21614 }
21615 {
21616 PyThreadState* __tstate = wxPyBeginAllowThreads();
21617 (arg1)->SetDirection(arg2);
21618
21619 wxPyEndAllowThreads(__tstate);
21620 if (PyErr_Occurred()) SWIG_fail;
21621 }
21622 Py_INCREF(Py_None); resultobj = Py_None;
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj;
21631 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21632 bool result;
21633 PyObject * obj0 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 {
21649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21650 }
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21660 bool arg2 ;
21661 PyObject * obj0 = 0 ;
21662 PyObject * obj1 = 0 ;
21663 char *kwnames[] = {
21664 (char *) "self",(char *) "ischange", NULL
21665 };
21666
21667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21669 if (SWIG_arg_fail(1)) SWIG_fail;
21670 {
21671 arg2 = (bool)(SWIG_As_bool(obj1));
21672 if (SWIG_arg_fail(2)) SWIG_fail;
21673 }
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 (arg1)->SetWindowChange(arg2);
21677
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 Py_INCREF(Py_None); resultobj = Py_None;
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21689 PyObject *resultobj;
21690 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21691 bool result;
21692 PyObject * obj0 = 0 ;
21693 char *kwnames[] = {
21694 (char *) "self", NULL
21695 };
21696
21697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21699 if (SWIG_arg_fail(1)) SWIG_fail;
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21703
21704 wxPyEndAllowThreads(__tstate);
21705 if (PyErr_Occurred()) SWIG_fail;
21706 }
21707 {
21708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21709 }
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21719 bool arg2 ;
21720 PyObject * obj0 = 0 ;
21721 PyObject * obj1 = 0 ;
21722 char *kwnames[] = {
21723 (char *) "self",(char *) "bIs", NULL
21724 };
21725
21726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21728 if (SWIG_arg_fail(1)) SWIG_fail;
21729 {
21730 arg2 = (bool)(SWIG_As_bool(obj1));
21731 if (SWIG_arg_fail(2)) SWIG_fail;
21732 }
21733 {
21734 PyThreadState* __tstate = wxPyBeginAllowThreads();
21735 (arg1)->SetFromTab(arg2);
21736
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 Py_INCREF(Py_None); resultobj = Py_None;
21741 return resultobj;
21742 fail:
21743 return NULL;
21744 }
21745
21746
21747 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21748 PyObject *resultobj;
21749 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21750 long arg2 ;
21751 PyObject * obj0 = 0 ;
21752 PyObject * obj1 = 0 ;
21753 char *kwnames[] = {
21754 (char *) "self",(char *) "flags", NULL
21755 };
21756
21757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21759 if (SWIG_arg_fail(1)) SWIG_fail;
21760 {
21761 arg2 = (long)(SWIG_As_long(obj1));
21762 if (SWIG_arg_fail(2)) SWIG_fail;
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 (arg1)->SetFlags(arg2);
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 Py_INCREF(Py_None); resultobj = Py_None;
21772 return resultobj;
21773 fail:
21774 return NULL;
21775 }
21776
21777
21778 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21779 PyObject *resultobj;
21780 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21781 wxWindow *result;
21782 PyObject * obj0 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21793
21794 wxPyEndAllowThreads(__tstate);
21795 if (PyErr_Occurred()) SWIG_fail;
21796 }
21797 {
21798 resultobj = wxPyMake_wxObject(result, 0);
21799 }
21800 return resultobj;
21801 fail:
21802 return NULL;
21803 }
21804
21805
21806 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21807 PyObject *resultobj;
21808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21809 wxWindow *arg2 = (wxWindow *) 0 ;
21810 PyObject * obj0 = 0 ;
21811 PyObject * obj1 = 0 ;
21812 char *kwnames[] = {
21813 (char *) "self",(char *) "win", NULL
21814 };
21815
21816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21818 if (SWIG_arg_fail(1)) SWIG_fail;
21819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21820 if (SWIG_arg_fail(2)) SWIG_fail;
21821 {
21822 PyThreadState* __tstate = wxPyBeginAllowThreads();
21823 (arg1)->SetCurrentFocus(arg2);
21824
21825 wxPyEndAllowThreads(__tstate);
21826 if (PyErr_Occurred()) SWIG_fail;
21827 }
21828 Py_INCREF(Py_None); resultobj = Py_None;
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21836 PyObject *obj;
21837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21838 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21839 Py_INCREF(obj);
21840 return Py_BuildValue((char *)"");
21841 }
21842 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxWindow *arg1 = (wxWindow *) NULL ;
21845 wxWindowCreateEvent *result;
21846 PyObject * obj0 = 0 ;
21847 char *kwnames[] = {
21848 (char *) "win", NULL
21849 };
21850
21851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21852 if (obj0) {
21853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21854 if (SWIG_arg_fail(1)) SWIG_fail;
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21859
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21873 wxWindow *result;
21874 PyObject * obj0 = 0 ;
21875 char *kwnames[] = {
21876 (char *) "self", NULL
21877 };
21878
21879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21881 if (SWIG_arg_fail(1)) SWIG_fail;
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21885
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = wxPyMake_wxObject(result, 0);
21891 }
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21899 PyObject *obj;
21900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21901 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21902 Py_INCREF(obj);
21903 return Py_BuildValue((char *)"");
21904 }
21905 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj;
21907 wxWindow *arg1 = (wxWindow *) NULL ;
21908 wxWindowDestroyEvent *result;
21909 PyObject * obj0 = 0 ;
21910 char *kwnames[] = {
21911 (char *) "win", NULL
21912 };
21913
21914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21915 if (obj0) {
21916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21917 if (SWIG_arg_fail(1)) SWIG_fail;
21918 }
21919 {
21920 PyThreadState* __tstate = wxPyBeginAllowThreads();
21921 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21922
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21927 return resultobj;
21928 fail:
21929 return NULL;
21930 }
21931
21932
21933 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj;
21935 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21936 wxWindow *result;
21937 PyObject * obj0 = 0 ;
21938 char *kwnames[] = {
21939 (char *) "self", NULL
21940 };
21941
21942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21944 if (SWIG_arg_fail(1)) SWIG_fail;
21945 {
21946 PyThreadState* __tstate = wxPyBeginAllowThreads();
21947 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21948
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 {
21953 resultobj = wxPyMake_wxObject(result, 0);
21954 }
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21962 PyObject *obj;
21963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21964 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21965 Py_INCREF(obj);
21966 return Py_BuildValue((char *)"");
21967 }
21968 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21969 PyObject *resultobj;
21970 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21971 int arg2 = (int) 0 ;
21972 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21973 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21974 wxContextMenuEvent *result;
21975 wxPoint temp3 ;
21976 PyObject * obj0 = 0 ;
21977 PyObject * obj1 = 0 ;
21978 PyObject * obj2 = 0 ;
21979 char *kwnames[] = {
21980 (char *) "type",(char *) "winid",(char *) "pt", NULL
21981 };
21982
21983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21984 if (obj0) {
21985 {
21986 arg1 = (wxEventType)(SWIG_As_int(obj0));
21987 if (SWIG_arg_fail(1)) SWIG_fail;
21988 }
21989 }
21990 if (obj1) {
21991 {
21992 arg2 = (int)(SWIG_As_int(obj1));
21993 if (SWIG_arg_fail(2)) SWIG_fail;
21994 }
21995 }
21996 if (obj2) {
21997 {
21998 arg3 = &temp3;
21999 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22000 }
22001 }
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22005
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj;
22018 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22019 wxPoint *result;
22020 PyObject * obj0 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 {
22031 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22032 result = (wxPoint *) &_result_ref;
22033 }
22034
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22039 return resultobj;
22040 fail:
22041 return NULL;
22042 }
22043
22044
22045 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22046 PyObject *resultobj;
22047 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22048 wxPoint *arg2 = 0 ;
22049 wxPoint temp2 ;
22050 PyObject * obj0 = 0 ;
22051 PyObject * obj1 = 0 ;
22052 char *kwnames[] = {
22053 (char *) "self",(char *) "pos", NULL
22054 };
22055
22056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22058 if (SWIG_arg_fail(1)) SWIG_fail;
22059 {
22060 arg2 = &temp2;
22061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22062 }
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 (arg1)->SetPosition((wxPoint const &)*arg2);
22066
22067 wxPyEndAllowThreads(__tstate);
22068 if (PyErr_Occurred()) SWIG_fail;
22069 }
22070 Py_INCREF(Py_None); resultobj = Py_None;
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22078 PyObject *obj;
22079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22080 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22081 Py_INCREF(obj);
22082 return Py_BuildValue((char *)"");
22083 }
22084 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22085 PyObject *resultobj;
22086 wxIdleEvent *result;
22087 char *kwnames[] = {
22088 NULL
22089 };
22090
22091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 result = (wxIdleEvent *)new wxIdleEvent();
22095
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj;
22108 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22109 bool arg2 = (bool) true ;
22110 PyObject * obj0 = 0 ;
22111 PyObject * obj1 = 0 ;
22112 char *kwnames[] = {
22113 (char *) "self",(char *) "needMore", NULL
22114 };
22115
22116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22118 if (SWIG_arg_fail(1)) SWIG_fail;
22119 if (obj1) {
22120 {
22121 arg2 = (bool)(SWIG_As_bool(obj1));
22122 if (SWIG_arg_fail(2)) SWIG_fail;
22123 }
22124 }
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 (arg1)->RequestMore(arg2);
22128
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 Py_INCREF(Py_None); resultobj = Py_None;
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22142 bool result;
22143 PyObject * obj0 = 0 ;
22144 char *kwnames[] = {
22145 (char *) "self", NULL
22146 };
22147
22148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(1)) SWIG_fail;
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22154
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 {
22159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22160 }
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj;
22169 wxIdleMode arg1 ;
22170 PyObject * obj0 = 0 ;
22171 char *kwnames[] = {
22172 (char *) "mode", NULL
22173 };
22174
22175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22176 {
22177 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22178 if (SWIG_arg_fail(1)) SWIG_fail;
22179 }
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 wxIdleEvent::SetMode((wxIdleMode )arg1);
22183
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 Py_INCREF(Py_None); resultobj = Py_None;
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22195 PyObject *resultobj;
22196 wxIdleMode result;
22197 char *kwnames[] = {
22198 NULL
22199 };
22200
22201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (wxIdleMode)wxIdleEvent::GetMode();
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 resultobj = SWIG_From_int((result));
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxWindow *arg1 = (wxWindow *) 0 ;
22219 bool result;
22220 PyObject * obj0 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "win", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 {
22229 PyThreadState* __tstate = wxPyBeginAllowThreads();
22230 result = (bool)wxIdleEvent::CanSend(arg1);
22231
22232 wxPyEndAllowThreads(__tstate);
22233 if (PyErr_Occurred()) SWIG_fail;
22234 }
22235 {
22236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22237 }
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22245 PyObject *obj;
22246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22247 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22248 Py_INCREF(obj);
22249 return Py_BuildValue((char *)"");
22250 }
22251 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 int arg1 = (int) 0 ;
22254 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22255 wxPyEvent *result;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258 char *kwnames[] = {
22259 (char *) "winid",(char *) "commandType", NULL
22260 };
22261
22262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22263 if (obj0) {
22264 {
22265 arg1 = (int)(SWIG_As_int(obj0));
22266 if (SWIG_arg_fail(1)) SWIG_fail;
22267 }
22268 }
22269 if (obj1) {
22270 {
22271 arg2 = (wxEventType)(SWIG_As_int(obj1));
22272 if (SWIG_arg_fail(2)) SWIG_fail;
22273 }
22274 }
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22278
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22290 PyObject *resultobj;
22291 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22292 PyObject * obj0 = 0 ;
22293 char *kwnames[] = {
22294 (char *) "self", NULL
22295 };
22296
22297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22299 if (SWIG_arg_fail(1)) SWIG_fail;
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 delete arg1;
22303
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 Py_INCREF(Py_None); resultobj = Py_None;
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj;
22316 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22317 PyObject *arg2 = (PyObject *) 0 ;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 char *kwnames[] = {
22321 (char *) "self",(char *) "self", NULL
22322 };
22323
22324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22326 if (SWIG_arg_fail(1)) SWIG_fail;
22327 arg2 = obj1;
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 (arg1)->SetSelf(arg2);
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 Py_INCREF(Py_None); resultobj = Py_None;
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22343 PyObject *resultobj;
22344 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22345 PyObject *result;
22346 PyObject * obj0 = 0 ;
22347 char *kwnames[] = {
22348 (char *) "self", NULL
22349 };
22350
22351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22353 if (SWIG_arg_fail(1)) SWIG_fail;
22354 {
22355 PyThreadState* __tstate = wxPyBeginAllowThreads();
22356 result = (PyObject *)(arg1)->GetSelf();
22357
22358 wxPyEndAllowThreads(__tstate);
22359 if (PyErr_Occurred()) SWIG_fail;
22360 }
22361 resultobj = result;
22362 return resultobj;
22363 fail:
22364 return NULL;
22365 }
22366
22367
22368 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22369 PyObject *obj;
22370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22371 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22372 Py_INCREF(obj);
22373 return Py_BuildValue((char *)"");
22374 }
22375 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22376 PyObject *resultobj;
22377 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22378 int arg2 = (int) 0 ;
22379 wxPyCommandEvent *result;
22380 PyObject * obj0 = 0 ;
22381 PyObject * obj1 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "commandType",(char *) "id", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22387 if (obj0) {
22388 {
22389 arg1 = (wxEventType)(SWIG_As_int(obj0));
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 }
22392 }
22393 if (obj1) {
22394 {
22395 arg2 = (int)(SWIG_As_int(obj1));
22396 if (SWIG_arg_fail(2)) SWIG_fail;
22397 }
22398 }
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22402
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22414 PyObject *resultobj;
22415 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22416 PyObject * obj0 = 0 ;
22417 char *kwnames[] = {
22418 (char *) "self", NULL
22419 };
22420
22421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22423 if (SWIG_arg_fail(1)) SWIG_fail;
22424 {
22425 PyThreadState* __tstate = wxPyBeginAllowThreads();
22426 delete arg1;
22427
22428 wxPyEndAllowThreads(__tstate);
22429 if (PyErr_Occurred()) SWIG_fail;
22430 }
22431 Py_INCREF(Py_None); resultobj = Py_None;
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22439 PyObject *resultobj;
22440 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22441 PyObject *arg2 = (PyObject *) 0 ;
22442 PyObject * obj0 = 0 ;
22443 PyObject * obj1 = 0 ;
22444 char *kwnames[] = {
22445 (char *) "self",(char *) "self", NULL
22446 };
22447
22448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22450 if (SWIG_arg_fail(1)) SWIG_fail;
22451 arg2 = obj1;
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 (arg1)->SetSelf(arg2);
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 Py_INCREF(Py_None); resultobj = Py_None;
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj;
22468 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22469 PyObject *result;
22470 PyObject * obj0 = 0 ;
22471 char *kwnames[] = {
22472 (char *) "self", NULL
22473 };
22474
22475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22477 if (SWIG_arg_fail(1)) SWIG_fail;
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = (PyObject *)(arg1)->GetSelf();
22481
22482 wxPyEndAllowThreads(__tstate);
22483 if (PyErr_Occurred()) SWIG_fail;
22484 }
22485 resultobj = result;
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22493 PyObject *obj;
22494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22495 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22496 Py_INCREF(obj);
22497 return Py_BuildValue((char *)"");
22498 }
22499 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj;
22501 wxWindow *arg1 = (wxWindow *) 0 ;
22502 wxDateTime *arg2 = 0 ;
22503 wxEventType arg3 ;
22504 wxDateEvent *result;
22505 PyObject * obj0 = 0 ;
22506 PyObject * obj1 = 0 ;
22507 PyObject * obj2 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "win",(char *) "dt",(char *) "type", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22517 if (SWIG_arg_fail(2)) SWIG_fail;
22518 if (arg2 == NULL) {
22519 SWIG_null_ref("wxDateTime");
22520 }
22521 if (SWIG_arg_fail(2)) SWIG_fail;
22522 }
22523 {
22524 arg3 = (wxEventType)(SWIG_As_int(obj2));
22525 if (SWIG_arg_fail(3)) SWIG_fail;
22526 }
22527 {
22528 PyThreadState* __tstate = wxPyBeginAllowThreads();
22529 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22530
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22542 PyObject *resultobj;
22543 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22544 wxDateTime *result;
22545 PyObject * obj0 = 0 ;
22546 char *kwnames[] = {
22547 (char *) "self", NULL
22548 };
22549
22550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22552 if (SWIG_arg_fail(1)) SWIG_fail;
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 {
22556 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22557 result = (wxDateTime *) &_result_ref;
22558 }
22559
22560 wxPyEndAllowThreads(__tstate);
22561 if (PyErr_Occurred()) SWIG_fail;
22562 }
22563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj;
22572 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22573 wxDateTime *arg2 = 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 char *kwnames[] = {
22577 (char *) "self",(char *) "date", NULL
22578 };
22579
22580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22582 if (SWIG_arg_fail(1)) SWIG_fail;
22583 {
22584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22585 if (SWIG_arg_fail(2)) SWIG_fail;
22586 if (arg2 == NULL) {
22587 SWIG_null_ref("wxDateTime");
22588 }
22589 if (SWIG_arg_fail(2)) SWIG_fail;
22590 }
22591 {
22592 PyThreadState* __tstate = wxPyBeginAllowThreads();
22593 (arg1)->SetDate((wxDateTime const &)*arg2);
22594
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 Py_INCREF(Py_None); resultobj = Py_None;
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22606 PyObject *obj;
22607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22608 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22609 Py_INCREF(obj);
22610 return Py_BuildValue((char *)"");
22611 }
22612 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22613 PyObject *resultobj;
22614 wxPyApp *result;
22615 char *kwnames[] = {
22616 NULL
22617 };
22618
22619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (wxPyApp *)new_wxPyApp();
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj;
22636 wxPyApp *arg1 = (wxPyApp *) 0 ;
22637 PyObject * obj0 = 0 ;
22638 char *kwnames[] = {
22639 (char *) "self", NULL
22640 };
22641
22642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 delete arg1;
22648
22649 wxPyEndAllowThreads(__tstate);
22650 if (PyErr_Occurred()) SWIG_fail;
22651 }
22652 Py_INCREF(Py_None); resultobj = Py_None;
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22660 PyObject *resultobj;
22661 wxPyApp *arg1 = (wxPyApp *) 0 ;
22662 PyObject *arg2 = (PyObject *) 0 ;
22663 PyObject *arg3 = (PyObject *) 0 ;
22664 bool arg4 ;
22665 PyObject * obj0 = 0 ;
22666 PyObject * obj1 = 0 ;
22667 PyObject * obj2 = 0 ;
22668 PyObject * obj3 = 0 ;
22669 char *kwnames[] = {
22670 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22671 };
22672
22673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22675 if (SWIG_arg_fail(1)) SWIG_fail;
22676 arg2 = obj1;
22677 arg3 = obj2;
22678 {
22679 arg4 = (bool)(SWIG_As_bool(obj3));
22680 if (SWIG_arg_fail(4)) SWIG_fail;
22681 }
22682 {
22683 PyThreadState* __tstate = wxPyBeginAllowThreads();
22684 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22685
22686 wxPyEndAllowThreads(__tstate);
22687 if (PyErr_Occurred()) SWIG_fail;
22688 }
22689 Py_INCREF(Py_None); resultobj = Py_None;
22690 return resultobj;
22691 fail:
22692 return NULL;
22693 }
22694
22695
22696 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22697 PyObject *resultobj;
22698 wxPyApp *arg1 = (wxPyApp *) 0 ;
22699 wxString result;
22700 PyObject * obj0 = 0 ;
22701 char *kwnames[] = {
22702 (char *) "self", NULL
22703 };
22704
22705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22707 if (SWIG_arg_fail(1)) SWIG_fail;
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = ((wxPyApp const *)arg1)->GetAppName();
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 {
22716 #if wxUSE_UNICODE
22717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22718 #else
22719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22720 #endif
22721 }
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj;
22730 wxPyApp *arg1 = (wxPyApp *) 0 ;
22731 wxString *arg2 = 0 ;
22732 bool temp2 = false ;
22733 PyObject * obj0 = 0 ;
22734 PyObject * obj1 = 0 ;
22735 char *kwnames[] = {
22736 (char *) "self",(char *) "name", NULL
22737 };
22738
22739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22741 if (SWIG_arg_fail(1)) SWIG_fail;
22742 {
22743 arg2 = wxString_in_helper(obj1);
22744 if (arg2 == NULL) SWIG_fail;
22745 temp2 = true;
22746 }
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 (arg1)->SetAppName((wxString const &)*arg2);
22750
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 Py_INCREF(Py_None); resultobj = Py_None;
22755 {
22756 if (temp2)
22757 delete arg2;
22758 }
22759 return resultobj;
22760 fail:
22761 {
22762 if (temp2)
22763 delete arg2;
22764 }
22765 return NULL;
22766 }
22767
22768
22769 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22770 PyObject *resultobj;
22771 wxPyApp *arg1 = (wxPyApp *) 0 ;
22772 wxString result;
22773 PyObject * obj0 = 0 ;
22774 char *kwnames[] = {
22775 (char *) "self", NULL
22776 };
22777
22778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22780 if (SWIG_arg_fail(1)) SWIG_fail;
22781 {
22782 PyThreadState* __tstate = wxPyBeginAllowThreads();
22783 result = ((wxPyApp const *)arg1)->GetClassName();
22784
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 {
22789 #if wxUSE_UNICODE
22790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22791 #else
22792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22793 #endif
22794 }
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22802 PyObject *resultobj;
22803 wxPyApp *arg1 = (wxPyApp *) 0 ;
22804 wxString *arg2 = 0 ;
22805 bool temp2 = false ;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808 char *kwnames[] = {
22809 (char *) "self",(char *) "name", NULL
22810 };
22811
22812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22814 if (SWIG_arg_fail(1)) SWIG_fail;
22815 {
22816 arg2 = wxString_in_helper(obj1);
22817 if (arg2 == NULL) SWIG_fail;
22818 temp2 = true;
22819 }
22820 {
22821 PyThreadState* __tstate = wxPyBeginAllowThreads();
22822 (arg1)->SetClassName((wxString const &)*arg2);
22823
22824 wxPyEndAllowThreads(__tstate);
22825 if (PyErr_Occurred()) SWIG_fail;
22826 }
22827 Py_INCREF(Py_None); resultobj = Py_None;
22828 {
22829 if (temp2)
22830 delete arg2;
22831 }
22832 return resultobj;
22833 fail:
22834 {
22835 if (temp2)
22836 delete arg2;
22837 }
22838 return NULL;
22839 }
22840
22841
22842 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22843 PyObject *resultobj;
22844 wxPyApp *arg1 = (wxPyApp *) 0 ;
22845 wxString *result;
22846 PyObject * obj0 = 0 ;
22847 char *kwnames[] = {
22848 (char *) "self", NULL
22849 };
22850
22851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22853 if (SWIG_arg_fail(1)) SWIG_fail;
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 {
22857 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22858 result = (wxString *) &_result_ref;
22859 }
22860
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 {
22865 #if wxUSE_UNICODE
22866 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22867 #else
22868 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22869 #endif
22870 }
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22878 PyObject *resultobj;
22879 wxPyApp *arg1 = (wxPyApp *) 0 ;
22880 wxString *arg2 = 0 ;
22881 bool temp2 = false ;
22882 PyObject * obj0 = 0 ;
22883 PyObject * obj1 = 0 ;
22884 char *kwnames[] = {
22885 (char *) "self",(char *) "name", NULL
22886 };
22887
22888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22890 if (SWIG_arg_fail(1)) SWIG_fail;
22891 {
22892 arg2 = wxString_in_helper(obj1);
22893 if (arg2 == NULL) SWIG_fail;
22894 temp2 = true;
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 (arg1)->SetVendorName((wxString const &)*arg2);
22899
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 Py_INCREF(Py_None); resultobj = Py_None;
22904 {
22905 if (temp2)
22906 delete arg2;
22907 }
22908 return resultobj;
22909 fail:
22910 {
22911 if (temp2)
22912 delete arg2;
22913 }
22914 return NULL;
22915 }
22916
22917
22918 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22919 PyObject *resultobj;
22920 wxPyApp *arg1 = (wxPyApp *) 0 ;
22921 wxAppTraits *result;
22922 PyObject * obj0 = 0 ;
22923 char *kwnames[] = {
22924 (char *) "self", NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22929 if (SWIG_arg_fail(1)) SWIG_fail;
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = (wxAppTraits *)(arg1)->GetTraits();
22933
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22938 return resultobj;
22939 fail:
22940 return NULL;
22941 }
22942
22943
22944 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22945 PyObject *resultobj;
22946 wxPyApp *arg1 = (wxPyApp *) 0 ;
22947 PyObject * obj0 = 0 ;
22948 char *kwnames[] = {
22949 (char *) "self", NULL
22950 };
22951
22952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22954 if (SWIG_arg_fail(1)) SWIG_fail;
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 (arg1)->ProcessPendingEvents();
22958
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 Py_INCREF(Py_None); resultobj = Py_None;
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj;
22971 wxPyApp *arg1 = (wxPyApp *) 0 ;
22972 bool arg2 = (bool) false ;
22973 bool result;
22974 PyObject * obj0 = 0 ;
22975 PyObject * obj1 = 0 ;
22976 char *kwnames[] = {
22977 (char *) "self",(char *) "onlyIfNeeded", NULL
22978 };
22979
22980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22982 if (SWIG_arg_fail(1)) SWIG_fail;
22983 if (obj1) {
22984 {
22985 arg2 = (bool)(SWIG_As_bool(obj1));
22986 if (SWIG_arg_fail(2)) SWIG_fail;
22987 }
22988 }
22989 {
22990 PyThreadState* __tstate = wxPyBeginAllowThreads();
22991 result = (bool)(arg1)->Yield(arg2);
22992
22993 wxPyEndAllowThreads(__tstate);
22994 if (PyErr_Occurred()) SWIG_fail;
22995 }
22996 {
22997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22998 }
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23006 PyObject *resultobj;
23007 wxPyApp *arg1 = (wxPyApp *) 0 ;
23008 PyObject * obj0 = 0 ;
23009 char *kwnames[] = {
23010 (char *) "self", NULL
23011 };
23012
23013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(1)) SWIG_fail;
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 (arg1)->WakeUpIdle();
23019
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 Py_INCREF(Py_None); resultobj = Py_None;
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj;
23032 bool result;
23033 char *kwnames[] = {
23034 NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23038 {
23039 PyThreadState* __tstate = wxPyBeginAllowThreads();
23040 result = (bool)wxPyApp::IsMainLoopRunning();
23041
23042 wxPyEndAllowThreads(__tstate);
23043 if (PyErr_Occurred()) SWIG_fail;
23044 }
23045 {
23046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23047 }
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23055 PyObject *resultobj;
23056 wxPyApp *arg1 = (wxPyApp *) 0 ;
23057 int result;
23058 PyObject * obj0 = 0 ;
23059 char *kwnames[] = {
23060 (char *) "self", NULL
23061 };
23062
23063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23065 if (SWIG_arg_fail(1)) SWIG_fail;
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (int)(arg1)->MainLoop();
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = SWIG_From_int((int)(result));
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxPyApp *arg1 = (wxPyApp *) 0 ;
23085 PyObject * obj0 = 0 ;
23086 char *kwnames[] = {
23087 (char *) "self", NULL
23088 };
23089
23090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23092 if (SWIG_arg_fail(1)) SWIG_fail;
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 (arg1)->Exit();
23096
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 Py_INCREF(Py_None); resultobj = Py_None;
23101 return resultobj;
23102 fail:
23103 return NULL;
23104 }
23105
23106
23107 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23108 PyObject *resultobj;
23109 wxPyApp *arg1 = (wxPyApp *) 0 ;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 (arg1)->ExitMainLoop();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 Py_INCREF(Py_None); resultobj = Py_None;
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj;
23134 wxPyApp *arg1 = (wxPyApp *) 0 ;
23135 bool result;
23136 PyObject * obj0 = 0 ;
23137 char *kwnames[] = {
23138 (char *) "self", NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(1)) SWIG_fail;
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (bool)(arg1)->Pending();
23147
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 {
23152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23153 }
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 wxPyApp *arg1 = (wxPyApp *) 0 ;
23163 bool result;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)(arg1)->Dispatch();
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxPyApp *arg1 = (wxPyApp *) 0 ;
23191 bool result;
23192 PyObject * obj0 = 0 ;
23193 char *kwnames[] = {
23194 (char *) "self", NULL
23195 };
23196
23197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23199 if (SWIG_arg_fail(1)) SWIG_fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)(arg1)->ProcessIdle();
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 wxPyApp *arg1 = (wxPyApp *) 0 ;
23219 wxWindow *arg2 = (wxWindow *) 0 ;
23220 wxIdleEvent *arg3 = 0 ;
23221 bool result;
23222 PyObject * obj0 = 0 ;
23223 PyObject * obj1 = 0 ;
23224 PyObject * obj2 = 0 ;
23225 char *kwnames[] = {
23226 (char *) "self",(char *) "win",(char *) "event", NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23231 if (SWIG_arg_fail(1)) SWIG_fail;
23232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23233 if (SWIG_arg_fail(2)) SWIG_fail;
23234 {
23235 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23236 if (SWIG_arg_fail(3)) SWIG_fail;
23237 if (arg3 == NULL) {
23238 SWIG_null_ref("wxIdleEvent");
23239 }
23240 if (SWIG_arg_fail(3)) SWIG_fail;
23241 }
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 wxPyApp *arg1 = (wxPyApp *) 0 ;
23261 bool result;
23262 PyObject * obj0 = 0 ;
23263 char *kwnames[] = {
23264 (char *) "self", NULL
23265 };
23266
23267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (bool)((wxPyApp const *)arg1)->IsActive();
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxPyApp *arg1 = (wxPyApp *) 0 ;
23289 wxWindow *arg2 = (wxWindow *) 0 ;
23290 PyObject * obj0 = 0 ;
23291 PyObject * obj1 = 0 ;
23292 char *kwnames[] = {
23293 (char *) "self",(char *) "win", NULL
23294 };
23295
23296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23298 if (SWIG_arg_fail(1)) SWIG_fail;
23299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23300 if (SWIG_arg_fail(2)) SWIG_fail;
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 (arg1)->SetTopWindow(arg2);
23304
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 Py_INCREF(Py_None); resultobj = Py_None;
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23316 PyObject *resultobj;
23317 wxPyApp *arg1 = (wxPyApp *) 0 ;
23318 wxWindow *result;
23319 PyObject * obj0 = 0 ;
23320 char *kwnames[] = {
23321 (char *) "self", NULL
23322 };
23323
23324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(1)) SWIG_fail;
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23330
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 {
23335 resultobj = wxPyMake_wxObject(result, 0);
23336 }
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj;
23345 wxPyApp *arg1 = (wxPyApp *) 0 ;
23346 bool arg2 ;
23347 PyObject * obj0 = 0 ;
23348 PyObject * obj1 = 0 ;
23349 char *kwnames[] = {
23350 (char *) "self",(char *) "flag", NULL
23351 };
23352
23353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23355 if (SWIG_arg_fail(1)) SWIG_fail;
23356 {
23357 arg2 = (bool)(SWIG_As_bool(obj1));
23358 if (SWIG_arg_fail(2)) SWIG_fail;
23359 }
23360 {
23361 PyThreadState* __tstate = wxPyBeginAllowThreads();
23362 (arg1)->SetExitOnFrameDelete(arg2);
23363
23364 wxPyEndAllowThreads(__tstate);
23365 if (PyErr_Occurred()) SWIG_fail;
23366 }
23367 Py_INCREF(Py_None); resultobj = Py_None;
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj;
23376 wxPyApp *arg1 = (wxPyApp *) 0 ;
23377 bool result;
23378 PyObject * obj0 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "self", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23385 if (SWIG_arg_fail(1)) SWIG_fail;
23386 {
23387 PyThreadState* __tstate = wxPyBeginAllowThreads();
23388 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23389
23390 wxPyEndAllowThreads(__tstate);
23391 if (PyErr_Occurred()) SWIG_fail;
23392 }
23393 {
23394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23395 }
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj;
23404 wxPyApp *arg1 = (wxPyApp *) 0 ;
23405 bool arg2 ;
23406 PyObject * obj0 = 0 ;
23407 PyObject * obj1 = 0 ;
23408 char *kwnames[] = {
23409 (char *) "self",(char *) "flag", NULL
23410 };
23411
23412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23414 if (SWIG_arg_fail(1)) SWIG_fail;
23415 {
23416 arg2 = (bool)(SWIG_As_bool(obj1));
23417 if (SWIG_arg_fail(2)) SWIG_fail;
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 (arg1)->SetUseBestVisual(arg2);
23422
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 Py_INCREF(Py_None); resultobj = Py_None;
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 wxPyApp *arg1 = (wxPyApp *) 0 ;
23436 bool result;
23437 PyObject * obj0 = 0 ;
23438 char *kwnames[] = {
23439 (char *) "self", NULL
23440 };
23441
23442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23444 if (SWIG_arg_fail(1)) SWIG_fail;
23445 {
23446 PyThreadState* __tstate = wxPyBeginAllowThreads();
23447 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23448
23449 wxPyEndAllowThreads(__tstate);
23450 if (PyErr_Occurred()) SWIG_fail;
23451 }
23452 {
23453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23454 }
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj;
23463 wxPyApp *arg1 = (wxPyApp *) 0 ;
23464 int arg2 ;
23465 PyObject * obj0 = 0 ;
23466 PyObject * obj1 = 0 ;
23467 char *kwnames[] = {
23468 (char *) "self",(char *) "mode", NULL
23469 };
23470
23471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23473 if (SWIG_arg_fail(1)) SWIG_fail;
23474 {
23475 arg2 = (int)(SWIG_As_int(obj1));
23476 if (SWIG_arg_fail(2)) SWIG_fail;
23477 }
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 (arg1)->SetPrintMode(arg2);
23481
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 Py_INCREF(Py_None); resultobj = Py_None;
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj;
23494 wxPyApp *arg1 = (wxPyApp *) 0 ;
23495 int result;
23496 PyObject * obj0 = 0 ;
23497 char *kwnames[] = {
23498 (char *) "self", NULL
23499 };
23500
23501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23503 if (SWIG_arg_fail(1)) SWIG_fail;
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23507
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 resultobj = SWIG_From_int((int)(result));
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 wxPyApp *arg1 = (wxPyApp *) 0 ;
23523 int arg2 ;
23524 PyObject * obj0 = 0 ;
23525 PyObject * obj1 = 0 ;
23526 char *kwnames[] = {
23527 (char *) "self",(char *) "mode", NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23532 if (SWIG_arg_fail(1)) SWIG_fail;
23533 {
23534 arg2 = (int)(SWIG_As_int(obj1));
23535 if (SWIG_arg_fail(2)) SWIG_fail;
23536 }
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 (arg1)->SetAssertMode(arg2);
23540
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 Py_INCREF(Py_None); resultobj = Py_None;
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23552 PyObject *resultobj;
23553 wxPyApp *arg1 = (wxPyApp *) 0 ;
23554 int result;
23555 PyObject * obj0 = 0 ;
23556 char *kwnames[] = {
23557 (char *) "self", NULL
23558 };
23559
23560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23562 if (SWIG_arg_fail(1)) SWIG_fail;
23563 {
23564 PyThreadState* __tstate = wxPyBeginAllowThreads();
23565 result = (int)(arg1)->GetAssertMode();
23566
23567 wxPyEndAllowThreads(__tstate);
23568 if (PyErr_Occurred()) SWIG_fail;
23569 }
23570 {
23571 resultobj = SWIG_From_int((int)(result));
23572 }
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj;
23581 bool result;
23582 char *kwnames[] = {
23583 NULL
23584 };
23585
23586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 {
23595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23596 }
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj;
23605 long result;
23606 char *kwnames[] = {
23607 NULL
23608 };
23609
23610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23611 {
23612 PyThreadState* __tstate = wxPyBeginAllowThreads();
23613 result = (long)wxPyApp::GetMacAboutMenuItemId();
23614
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 {
23619 resultobj = SWIG_From_long((long)(result));
23620 }
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23628 PyObject *resultobj;
23629 long result;
23630 char *kwnames[] = {
23631 NULL
23632 };
23633
23634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23638
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = SWIG_From_long((long)(result));
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 long result;
23654 char *kwnames[] = {
23655 NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (long)wxPyApp::GetMacExitMenuItemId();
23662
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = SWIG_From_long((long)(result));
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj;
23677 wxString result;
23678 char *kwnames[] = {
23679 NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = wxPyApp::GetMacHelpMenuTitleName();
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 {
23691 #if wxUSE_UNICODE
23692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23693 #else
23694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23695 #endif
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23704 PyObject *resultobj;
23705 bool arg1 ;
23706 PyObject * obj0 = 0 ;
23707 char *kwnames[] = {
23708 (char *) "val", NULL
23709 };
23710
23711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23712 {
23713 arg1 = (bool)(SWIG_As_bool(obj0));
23714 if (SWIG_arg_fail(1)) SWIG_fail;
23715 }
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23719
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 Py_INCREF(Py_None); resultobj = Py_None;
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj;
23732 long arg1 ;
23733 PyObject * obj0 = 0 ;
23734 char *kwnames[] = {
23735 (char *) "val", NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23739 {
23740 arg1 = (long)(SWIG_As_long(obj0));
23741 if (SWIG_arg_fail(1)) SWIG_fail;
23742 }
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 wxPyApp::SetMacAboutMenuItemId(arg1);
23746
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 Py_INCREF(Py_None); resultobj = Py_None;
23751 return resultobj;
23752 fail:
23753 return NULL;
23754 }
23755
23756
23757 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23758 PyObject *resultobj;
23759 long arg1 ;
23760 PyObject * obj0 = 0 ;
23761 char *kwnames[] = {
23762 (char *) "val", NULL
23763 };
23764
23765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23766 {
23767 arg1 = (long)(SWIG_As_long(obj0));
23768 if (SWIG_arg_fail(1)) SWIG_fail;
23769 }
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 Py_INCREF(Py_None); resultobj = Py_None;
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj;
23786 long arg1 ;
23787 PyObject * obj0 = 0 ;
23788 char *kwnames[] = {
23789 (char *) "val", NULL
23790 };
23791
23792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23793 {
23794 arg1 = (long)(SWIG_As_long(obj0));
23795 if (SWIG_arg_fail(1)) SWIG_fail;
23796 }
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 wxPyApp::SetMacExitMenuItemId(arg1);
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_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj;
23813 wxString *arg1 = 0 ;
23814 bool temp1 = false ;
23815 PyObject * obj0 = 0 ;
23816 char *kwnames[] = {
23817 (char *) "val", NULL
23818 };
23819
23820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23821 {
23822 arg1 = wxString_in_helper(obj0);
23823 if (arg1 == NULL) SWIG_fail;
23824 temp1 = true;
23825 }
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 Py_INCREF(Py_None); resultobj = Py_None;
23834 {
23835 if (temp1)
23836 delete arg1;
23837 }
23838 return resultobj;
23839 fail:
23840 {
23841 if (temp1)
23842 delete arg1;
23843 }
23844 return NULL;
23845 }
23846
23847
23848 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23849 PyObject *resultobj;
23850 wxPyApp *arg1 = (wxPyApp *) 0 ;
23851 PyObject * obj0 = 0 ;
23852 char *kwnames[] = {
23853 (char *) "self", NULL
23854 };
23855
23856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23858 if (SWIG_arg_fail(1)) SWIG_fail;
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 (arg1)->_BootstrapApp();
23862
23863 wxPyEndAllowThreads(__tstate);
23864 if (PyErr_Occurred()) SWIG_fail;
23865 }
23866 Py_INCREF(Py_None); resultobj = Py_None;
23867 return resultobj;
23868 fail:
23869 return NULL;
23870 }
23871
23872
23873 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23874 PyObject *resultobj;
23875 int result;
23876 char *kwnames[] = {
23877 NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 result = (int)wxPyApp::GetComCtl32Version();
23884
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 {
23889 resultobj = SWIG_From_int((int)(result));
23890 }
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23898 PyObject *obj;
23899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23900 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23901 Py_INCREF(obj);
23902 return Py_BuildValue((char *)"");
23903 }
23904 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj;
23906 char *kwnames[] = {
23907 NULL
23908 };
23909
23910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 wxExit();
23914
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 Py_INCREF(Py_None); resultobj = Py_None;
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23926 PyObject *resultobj;
23927 bool result;
23928 char *kwnames[] = {
23929 NULL
23930 };
23931
23932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (bool)wxYield();
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_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj;
23951 bool result;
23952 char *kwnames[] = {
23953 NULL
23954 };
23955
23956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23957 {
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 result = (bool)wxYieldIfNeeded();
23960
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 {
23965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23966 }
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 wxWindow *arg1 = (wxWindow *) NULL ;
23976 bool arg2 = (bool) false ;
23977 bool result;
23978 PyObject * obj0 = 0 ;
23979 PyObject * obj1 = 0 ;
23980 char *kwnames[] = {
23981 (char *) "win",(char *) "onlyIfNeeded", NULL
23982 };
23983
23984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23985 if (obj0) {
23986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23987 if (SWIG_arg_fail(1)) SWIG_fail;
23988 }
23989 if (obj1) {
23990 {
23991 arg2 = (bool)(SWIG_As_bool(obj1));
23992 if (SWIG_arg_fail(2)) SWIG_fail;
23993 }
23994 }
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 result = (bool)wxSafeYield(arg1,arg2);
23998
23999 wxPyEndAllowThreads(__tstate);
24000 if (PyErr_Occurred()) SWIG_fail;
24001 }
24002 {
24003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24004 }
24005 return resultobj;
24006 fail:
24007 return NULL;
24008 }
24009
24010
24011 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24012 PyObject *resultobj;
24013 char *kwnames[] = {
24014 NULL
24015 };
24016
24017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 wxWakeUpIdle();
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 Py_INCREF(Py_None); resultobj = Py_None;
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj;
24034 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24035 wxEvent *arg2 = 0 ;
24036 PyObject * obj0 = 0 ;
24037 PyObject * obj1 = 0 ;
24038 char *kwnames[] = {
24039 (char *) "dest",(char *) "event", NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24044 if (SWIG_arg_fail(1)) SWIG_fail;
24045 {
24046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24047 if (SWIG_arg_fail(2)) SWIG_fail;
24048 if (arg2 == NULL) {
24049 SWIG_null_ref("wxEvent");
24050 }
24051 if (SWIG_arg_fail(2)) SWIG_fail;
24052 }
24053 {
24054 PyThreadState* __tstate = wxPyBeginAllowThreads();
24055 wxPostEvent(arg1,*arg2);
24056
24057 wxPyEndAllowThreads(__tstate);
24058 if (PyErr_Occurred()) SWIG_fail;
24059 }
24060 Py_INCREF(Py_None); resultobj = Py_None;
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24068 PyObject *resultobj;
24069 char *kwnames[] = {
24070 NULL
24071 };
24072
24073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24074 {
24075 PyThreadState* __tstate = wxPyBeginAllowThreads();
24076 wxApp_CleanUp();
24077
24078 wxPyEndAllowThreads(__tstate);
24079 if (PyErr_Occurred()) SWIG_fail;
24080 }
24081 Py_INCREF(Py_None); resultobj = Py_None;
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj;
24090 wxPyApp *result;
24091 char *kwnames[] = {
24092 NULL
24093 };
24094
24095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 result = (wxPyApp *)wxPyGetApp();
24099
24100 wxPyEndAllowThreads(__tstate);
24101 if (PyErr_Occurred()) SWIG_fail;
24102 }
24103 {
24104 resultobj = wxPyMake_wxObject(result, 0);
24105 }
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj;
24114 char *arg1 = (char *) 0 ;
24115 PyObject * obj0 = 0 ;
24116 char *kwnames[] = {
24117 (char *) "encoding", NULL
24118 };
24119
24120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24121 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24122 SWIG_arg_fail(1);SWIG_fail;
24123 }
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 wxSetDefaultPyEncoding((char const *)arg1);
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 Py_INCREF(Py_None); resultobj = Py_None;
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 char *result;
24141 char *kwnames[] = {
24142 NULL
24143 };
24144
24145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 result = (char *)wxGetDefaultPyEncoding();
24149
24150 wxPyEndAllowThreads(__tstate);
24151 if (PyErr_Occurred()) SWIG_fail;
24152 }
24153 resultobj = SWIG_FromCharPtr(result);
24154 return resultobj;
24155 fail:
24156 return NULL;
24157 }
24158
24159
24160 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24161 PyObject *resultobj;
24162 wxEventLoop *result;
24163 char *kwnames[] = {
24164 NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24168 {
24169 PyThreadState* __tstate = wxPyBeginAllowThreads();
24170 result = (wxEventLoop *)new wxEventLoop();
24171
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj;
24184 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24185 PyObject * obj0 = 0 ;
24186 char *kwnames[] = {
24187 (char *) "self", NULL
24188 };
24189
24190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24192 if (SWIG_arg_fail(1)) SWIG_fail;
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 delete arg1;
24196
24197 wxPyEndAllowThreads(__tstate);
24198 if (PyErr_Occurred()) SWIG_fail;
24199 }
24200 Py_INCREF(Py_None); resultobj = Py_None;
24201 return resultobj;
24202 fail:
24203 return NULL;
24204 }
24205
24206
24207 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24208 PyObject *resultobj;
24209 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24210 int result;
24211 PyObject * obj0 = 0 ;
24212 char *kwnames[] = {
24213 (char *) "self", NULL
24214 };
24215
24216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24218 if (SWIG_arg_fail(1)) SWIG_fail;
24219 {
24220 PyThreadState* __tstate = wxPyBeginAllowThreads();
24221 result = (int)(arg1)->Run();
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 {
24227 resultobj = SWIG_From_int((int)(result));
24228 }
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24236 PyObject *resultobj;
24237 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24238 int arg2 = (int) 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 char *kwnames[] = {
24242 (char *) "self",(char *) "rc", NULL
24243 };
24244
24245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24247 if (SWIG_arg_fail(1)) SWIG_fail;
24248 if (obj1) {
24249 {
24250 arg2 = (int)(SWIG_As_int(obj1));
24251 if (SWIG_arg_fail(2)) SWIG_fail;
24252 }
24253 }
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 (arg1)->Exit(arg2);
24257
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 Py_INCREF(Py_None); resultobj = Py_None;
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj;
24270 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24271 bool result;
24272 PyObject * obj0 = 0 ;
24273 char *kwnames[] = {
24274 (char *) "self", NULL
24275 };
24276
24277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24279 if (SWIG_arg_fail(1)) SWIG_fail;
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 result = (bool)((wxEventLoop const *)arg1)->Pending();
24283
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 {
24288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24289 }
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24299 bool result;
24300 PyObject * obj0 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (bool)(arg1)->Dispatch();
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24325 PyObject *resultobj;
24326 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24327 bool result;
24328 PyObject * obj0 = 0 ;
24329 char *kwnames[] = {
24330 (char *) "self", NULL
24331 };
24332
24333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(1)) SWIG_fail;
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 {
24344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxEventLoop *result;
24355 char *kwnames[] = {
24356 NULL
24357 };
24358
24359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 result = (wxEventLoop *)wxEventLoop::GetActive();
24363
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24375 PyObject *resultobj;
24376 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24377 PyObject * obj0 = 0 ;
24378 char *kwnames[] = {
24379 (char *) "loop", NULL
24380 };
24381
24382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 wxEventLoop::SetActive(arg1);
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 Py_INCREF(Py_None); resultobj = Py_None;
24393 return resultobj;
24394 fail:
24395 return NULL;
24396 }
24397
24398
24399 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24400 PyObject *obj;
24401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24402 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24403 Py_INCREF(obj);
24404 return Py_BuildValue((char *)"");
24405 }
24406 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 int arg1 = (int) 0 ;
24409 int arg2 = (int) 0 ;
24410 int arg3 = (int) 0 ;
24411 wxAcceleratorEntry *result;
24412 PyObject * obj0 = 0 ;
24413 PyObject * obj1 = 0 ;
24414 PyObject * obj2 = 0 ;
24415 char *kwnames[] = {
24416 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24417 };
24418
24419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24420 if (obj0) {
24421 {
24422 arg1 = (int)(SWIG_As_int(obj0));
24423 if (SWIG_arg_fail(1)) SWIG_fail;
24424 }
24425 }
24426 if (obj1) {
24427 {
24428 arg2 = (int)(SWIG_As_int(obj1));
24429 if (SWIG_arg_fail(2)) SWIG_fail;
24430 }
24431 }
24432 if (obj2) {
24433 {
24434 arg3 = (int)(SWIG_As_int(obj2));
24435 if (SWIG_arg_fail(3)) SWIG_fail;
24436 }
24437 }
24438 {
24439 PyThreadState* __tstate = wxPyBeginAllowThreads();
24440 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24441
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24446 return resultobj;
24447 fail:
24448 return NULL;
24449 }
24450
24451
24452 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24453 PyObject *resultobj;
24454 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24455 PyObject * obj0 = 0 ;
24456 char *kwnames[] = {
24457 (char *) "self", NULL
24458 };
24459
24460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24462 if (SWIG_arg_fail(1)) SWIG_fail;
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 delete arg1;
24466
24467 wxPyEndAllowThreads(__tstate);
24468 if (PyErr_Occurred()) SWIG_fail;
24469 }
24470 Py_INCREF(Py_None); resultobj = Py_None;
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj;
24479 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24480 int arg2 ;
24481 int arg3 ;
24482 int arg4 ;
24483 PyObject * obj0 = 0 ;
24484 PyObject * obj1 = 0 ;
24485 PyObject * obj2 = 0 ;
24486 PyObject * obj3 = 0 ;
24487 char *kwnames[] = {
24488 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24489 };
24490
24491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24493 if (SWIG_arg_fail(1)) SWIG_fail;
24494 {
24495 arg2 = (int)(SWIG_As_int(obj1));
24496 if (SWIG_arg_fail(2)) SWIG_fail;
24497 }
24498 {
24499 arg3 = (int)(SWIG_As_int(obj2));
24500 if (SWIG_arg_fail(3)) SWIG_fail;
24501 }
24502 {
24503 arg4 = (int)(SWIG_As_int(obj3));
24504 if (SWIG_arg_fail(4)) SWIG_fail;
24505 }
24506 {
24507 PyThreadState* __tstate = wxPyBeginAllowThreads();
24508 (arg1)->Set(arg2,arg3,arg4);
24509
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 Py_INCREF(Py_None); resultobj = Py_None;
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24521 PyObject *resultobj;
24522 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24523 int result;
24524 PyObject * obj0 = 0 ;
24525 char *kwnames[] = {
24526 (char *) "self", NULL
24527 };
24528
24529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24531 if (SWIG_arg_fail(1)) SWIG_fail;
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 result = (int)(arg1)->GetFlags();
24535
24536 wxPyEndAllowThreads(__tstate);
24537 if (PyErr_Occurred()) SWIG_fail;
24538 }
24539 {
24540 resultobj = SWIG_From_int((int)(result));
24541 }
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24551 int result;
24552 PyObject * obj0 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "self", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (int)(arg1)->GetKeyCode();
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = SWIG_From_int((int)(result));
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24579 int result;
24580 PyObject * obj0 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (int)(arg1)->GetCommand();
24591
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 {
24596 resultobj = SWIG_From_int((int)(result));
24597 }
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24605 PyObject *obj;
24606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24607 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24608 Py_INCREF(obj);
24609 return Py_BuildValue((char *)"");
24610 }
24611 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24612 PyObject *resultobj;
24613 int arg1 ;
24614 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24615 wxAcceleratorTable *result;
24616 PyObject * obj0 = 0 ;
24617 char *kwnames[] = {
24618 (char *) "n", NULL
24619 };
24620
24621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24622 {
24623 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24624 if (arg2) arg1 = PyList_Size(obj0);
24625 else arg1 = 0;
24626 }
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24630
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24635 {
24636 delete [] arg2;
24637 }
24638 return resultobj;
24639 fail:
24640 {
24641 delete [] arg2;
24642 }
24643 return NULL;
24644 }
24645
24646
24647 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24648 PyObject *resultobj;
24649 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24650 PyObject * obj0 = 0 ;
24651 char *kwnames[] = {
24652 (char *) "self", NULL
24653 };
24654
24655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24657 if (SWIG_arg_fail(1)) SWIG_fail;
24658 {
24659 PyThreadState* __tstate = wxPyBeginAllowThreads();
24660 delete arg1;
24661
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 Py_INCREF(Py_None); resultobj = Py_None;
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24673 PyObject *resultobj;
24674 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24675 bool result;
24676 PyObject * obj0 = 0 ;
24677 char *kwnames[] = {
24678 (char *) "self", NULL
24679 };
24680
24681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(1)) SWIG_fail;
24684 {
24685 PyThreadState* __tstate = wxPyBeginAllowThreads();
24686 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24687
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 {
24692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24693 }
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24701 PyObject *obj;
24702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24703 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24704 Py_INCREF(obj);
24705 return Py_BuildValue((char *)"");
24706 }
24707 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24708 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24709 return 1;
24710 }
24711
24712
24713 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24714 PyObject *pyobj;
24715
24716 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24717 return pyobj;
24718 }
24719
24720
24721 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24722 PyObject *resultobj;
24723 wxString *arg1 = 0 ;
24724 wxAcceleratorEntry *result;
24725 bool temp1 = false ;
24726 PyObject * obj0 = 0 ;
24727 char *kwnames[] = {
24728 (char *) "label", NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24732 {
24733 arg1 = wxString_in_helper(obj0);
24734 if (arg1 == NULL) SWIG_fail;
24735 temp1 = true;
24736 }
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24740
24741 wxPyEndAllowThreads(__tstate);
24742 if (PyErr_Occurred()) SWIG_fail;
24743 }
24744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24745 {
24746 if (temp1)
24747 delete arg1;
24748 }
24749 return resultobj;
24750 fail:
24751 {
24752 if (temp1)
24753 delete arg1;
24754 }
24755 return NULL;
24756 }
24757
24758
24759 static int _wrap_PanelNameStr_set(PyObject *) {
24760 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24761 return 1;
24762 }
24763
24764
24765 static PyObject *_wrap_PanelNameStr_get(void) {
24766 PyObject *pyobj;
24767
24768 {
24769 #if wxUSE_UNICODE
24770 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24771 #else
24772 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24773 #endif
24774 }
24775 return pyobj;
24776 }
24777
24778
24779 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxVisualAttributes *result;
24782 char *kwnames[] = {
24783 NULL
24784 };
24785
24786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxVisualAttributes *)new_wxVisualAttributes();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj;
24803 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24804 PyObject * obj0 = 0 ;
24805 char *kwnames[] = {
24806 (char *) "self", NULL
24807 };
24808
24809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24811 if (SWIG_arg_fail(1)) SWIG_fail;
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 delete_wxVisualAttributes(arg1);
24815
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 Py_INCREF(Py_None); resultobj = Py_None;
24820 return resultobj;
24821 fail:
24822 return NULL;
24823 }
24824
24825
24826 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24827 PyObject *resultobj;
24828 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24829 wxFont *arg2 = (wxFont *) 0 ;
24830 PyObject * obj0 = 0 ;
24831 PyObject * obj1 = 0 ;
24832 char *kwnames[] = {
24833 (char *) "self",(char *) "font", NULL
24834 };
24835
24836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24838 if (SWIG_arg_fail(1)) SWIG_fail;
24839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24840 if (SWIG_arg_fail(2)) SWIG_fail;
24841 if (arg1) (arg1)->font = *arg2;
24842
24843 Py_INCREF(Py_None); resultobj = Py_None;
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24853 wxFont *result;
24854 PyObject * obj0 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 result = (wxFont *)& ((arg1)->font);
24863
24864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj;
24873 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24874 wxColour *arg2 = (wxColour *) 0 ;
24875 PyObject * obj0 = 0 ;
24876 PyObject * obj1 = 0 ;
24877 char *kwnames[] = {
24878 (char *) "self",(char *) "colFg", NULL
24879 };
24880
24881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24883 if (SWIG_arg_fail(1)) SWIG_fail;
24884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24885 if (SWIG_arg_fail(2)) SWIG_fail;
24886 if (arg1) (arg1)->colFg = *arg2;
24887
24888 Py_INCREF(Py_None); resultobj = Py_None;
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24896 PyObject *resultobj;
24897 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24898 wxColour *result;
24899 PyObject * obj0 = 0 ;
24900 char *kwnames[] = {
24901 (char *) "self", NULL
24902 };
24903
24904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24906 if (SWIG_arg_fail(1)) SWIG_fail;
24907 result = (wxColour *)& ((arg1)->colFg);
24908
24909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24919 wxColour *arg2 = (wxColour *) 0 ;
24920 PyObject * obj0 = 0 ;
24921 PyObject * obj1 = 0 ;
24922 char *kwnames[] = {
24923 (char *) "self",(char *) "colBg", NULL
24924 };
24925
24926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24928 if (SWIG_arg_fail(1)) SWIG_fail;
24929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24930 if (SWIG_arg_fail(2)) SWIG_fail;
24931 if (arg1) (arg1)->colBg = *arg2;
24932
24933 Py_INCREF(Py_None); resultobj = Py_None;
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24941 PyObject *resultobj;
24942 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24943 wxColour *result;
24944 PyObject * obj0 = 0 ;
24945 char *kwnames[] = {
24946 (char *) "self", NULL
24947 };
24948
24949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(1)) SWIG_fail;
24952 result = (wxColour *)& ((arg1)->colBg);
24953
24954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24962 PyObject *obj;
24963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24964 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24965 Py_INCREF(obj);
24966 return Py_BuildValue((char *)"");
24967 }
24968 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj;
24970 wxWindow *arg1 = (wxWindow *) 0 ;
24971 int arg2 = (int) (int)-1 ;
24972 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24973 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24974 wxSize const &arg4_defvalue = wxDefaultSize ;
24975 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24976 long arg5 = (long) 0 ;
24977 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24978 wxString *arg6 = (wxString *) &arg6_defvalue ;
24979 wxWindow *result;
24980 wxPoint temp3 ;
24981 wxSize temp4 ;
24982 bool temp6 = false ;
24983 PyObject * obj0 = 0 ;
24984 PyObject * obj1 = 0 ;
24985 PyObject * obj2 = 0 ;
24986 PyObject * obj3 = 0 ;
24987 PyObject * obj4 = 0 ;
24988 PyObject * obj5 = 0 ;
24989 char *kwnames[] = {
24990 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24991 };
24992
24993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24995 if (SWIG_arg_fail(1)) SWIG_fail;
24996 if (obj1) {
24997 {
24998 arg2 = (int const)(SWIG_As_int(obj1));
24999 if (SWIG_arg_fail(2)) SWIG_fail;
25000 }
25001 }
25002 if (obj2) {
25003 {
25004 arg3 = &temp3;
25005 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25006 }
25007 }
25008 if (obj3) {
25009 {
25010 arg4 = &temp4;
25011 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25012 }
25013 }
25014 if (obj4) {
25015 {
25016 arg5 = (long)(SWIG_As_long(obj4));
25017 if (SWIG_arg_fail(5)) SWIG_fail;
25018 }
25019 }
25020 if (obj5) {
25021 {
25022 arg6 = wxString_in_helper(obj5);
25023 if (arg6 == NULL) SWIG_fail;
25024 temp6 = true;
25025 }
25026 }
25027 {
25028 if (!wxPyCheckForApp()) SWIG_fail;
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25031
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25036 {
25037 if (temp6)
25038 delete arg6;
25039 }
25040 return resultobj;
25041 fail:
25042 {
25043 if (temp6)
25044 delete arg6;
25045 }
25046 return NULL;
25047 }
25048
25049
25050 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj;
25052 wxWindow *result;
25053 char *kwnames[] = {
25054 NULL
25055 };
25056
25057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25058 {
25059 if (!wxPyCheckForApp()) SWIG_fail;
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (wxWindow *)new wxWindow();
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj;
25075 wxWindow *arg1 = (wxWindow *) 0 ;
25076 wxWindow *arg2 = (wxWindow *) 0 ;
25077 int arg3 = (int) (int)-1 ;
25078 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25079 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25080 wxSize const &arg5_defvalue = wxDefaultSize ;
25081 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25082 long arg6 = (long) 0 ;
25083 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25084 wxString *arg7 = (wxString *) &arg7_defvalue ;
25085 bool result;
25086 wxPoint temp4 ;
25087 wxSize temp5 ;
25088 bool temp7 = false ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 PyObject * obj2 = 0 ;
25092 PyObject * obj3 = 0 ;
25093 PyObject * obj4 = 0 ;
25094 PyObject * obj5 = 0 ;
25095 PyObject * obj6 = 0 ;
25096 char *kwnames[] = {
25097 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25098 };
25099
25100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25102 if (SWIG_arg_fail(1)) SWIG_fail;
25103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25104 if (SWIG_arg_fail(2)) SWIG_fail;
25105 if (obj2) {
25106 {
25107 arg3 = (int const)(SWIG_As_int(obj2));
25108 if (SWIG_arg_fail(3)) SWIG_fail;
25109 }
25110 }
25111 if (obj3) {
25112 {
25113 arg4 = &temp4;
25114 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25115 }
25116 }
25117 if (obj4) {
25118 {
25119 arg5 = &temp5;
25120 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25121 }
25122 }
25123 if (obj5) {
25124 {
25125 arg6 = (long)(SWIG_As_long(obj5));
25126 if (SWIG_arg_fail(6)) SWIG_fail;
25127 }
25128 }
25129 if (obj6) {
25130 {
25131 arg7 = wxString_in_helper(obj6);
25132 if (arg7 == NULL) SWIG_fail;
25133 temp7 = true;
25134 }
25135 }
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 {
25144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25145 }
25146 {
25147 if (temp7)
25148 delete arg7;
25149 }
25150 return resultobj;
25151 fail:
25152 {
25153 if (temp7)
25154 delete arg7;
25155 }
25156 return NULL;
25157 }
25158
25159
25160 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25161 PyObject *resultobj;
25162 wxWindow *arg1 = (wxWindow *) 0 ;
25163 bool arg2 = (bool) false ;
25164 bool result;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self",(char *) "force", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) 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 if (obj1) {
25175 {
25176 arg2 = (bool)(SWIG_As_bool(obj1));
25177 if (SWIG_arg_fail(2)) SWIG_fail;
25178 }
25179 }
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (bool)(arg1)->Close(arg2);
25183
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj;
25198 wxWindow *arg1 = (wxWindow *) 0 ;
25199 bool result;
25200 PyObject * obj0 = 0 ;
25201 char *kwnames[] = {
25202 (char *) "self", NULL
25203 };
25204
25205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (bool)(arg1)->Destroy();
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxWindow *arg1 = (wxWindow *) 0 ;
25227 bool result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "self", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25235 if (SWIG_arg_fail(1)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = (bool)(arg1)->DestroyChildren();
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 {
25244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25245 }
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxWindow *arg1 = (wxWindow *) 0 ;
25255 bool result;
25256 PyObject * obj0 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 {
25272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25273 }
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 wxString *arg2 = 0 ;
25284 bool temp2 = false ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self",(char *) "title", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 arg2 = wxString_in_helper(obj1);
25296 if (arg2 == NULL) SWIG_fail;
25297 temp2 = true;
25298 }
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 (arg1)->SetTitle((wxString const &)*arg2);
25302
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 Py_INCREF(Py_None); resultobj = Py_None;
25307 {
25308 if (temp2)
25309 delete arg2;
25310 }
25311 return resultobj;
25312 fail:
25313 {
25314 if (temp2)
25315 delete arg2;
25316 }
25317 return NULL;
25318 }
25319
25320
25321 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25322 PyObject *resultobj;
25323 wxWindow *arg1 = (wxWindow *) 0 ;
25324 wxString result;
25325 PyObject * obj0 = 0 ;
25326 char *kwnames[] = {
25327 (char *) "self", NULL
25328 };
25329
25330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25332 if (SWIG_arg_fail(1)) SWIG_fail;
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = ((wxWindow const *)arg1)->GetTitle();
25336
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 {
25341 #if wxUSE_UNICODE
25342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25343 #else
25344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25345 #endif
25346 }
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25354 PyObject *resultobj;
25355 wxWindow *arg1 = (wxWindow *) 0 ;
25356 wxString *arg2 = 0 ;
25357 bool temp2 = false ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char *kwnames[] = {
25361 (char *) "self",(char *) "label", NULL
25362 };
25363
25364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25366 if (SWIG_arg_fail(1)) SWIG_fail;
25367 {
25368 arg2 = wxString_in_helper(obj1);
25369 if (arg2 == NULL) SWIG_fail;
25370 temp2 = true;
25371 }
25372 {
25373 PyThreadState* __tstate = wxPyBeginAllowThreads();
25374 (arg1)->SetLabel((wxString const &)*arg2);
25375
25376 wxPyEndAllowThreads(__tstate);
25377 if (PyErr_Occurred()) SWIG_fail;
25378 }
25379 Py_INCREF(Py_None); resultobj = Py_None;
25380 {
25381 if (temp2)
25382 delete arg2;
25383 }
25384 return resultobj;
25385 fail:
25386 {
25387 if (temp2)
25388 delete arg2;
25389 }
25390 return NULL;
25391 }
25392
25393
25394 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25395 PyObject *resultobj;
25396 wxWindow *arg1 = (wxWindow *) 0 ;
25397 wxString result;
25398 PyObject * obj0 = 0 ;
25399 char *kwnames[] = {
25400 (char *) "self", NULL
25401 };
25402
25403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25405 if (SWIG_arg_fail(1)) SWIG_fail;
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = ((wxWindow const *)arg1)->GetLabel();
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 #if wxUSE_UNICODE
25415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25416 #else
25417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25418 #endif
25419 }
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25427 PyObject *resultobj;
25428 wxWindow *arg1 = (wxWindow *) 0 ;
25429 wxString *arg2 = 0 ;
25430 bool temp2 = false ;
25431 PyObject * obj0 = 0 ;
25432 PyObject * obj1 = 0 ;
25433 char *kwnames[] = {
25434 (char *) "self",(char *) "name", NULL
25435 };
25436
25437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25439 if (SWIG_arg_fail(1)) SWIG_fail;
25440 {
25441 arg2 = wxString_in_helper(obj1);
25442 if (arg2 == NULL) SWIG_fail;
25443 temp2 = true;
25444 }
25445 {
25446 PyThreadState* __tstate = wxPyBeginAllowThreads();
25447 (arg1)->SetName((wxString const &)*arg2);
25448
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 Py_INCREF(Py_None); resultobj = Py_None;
25453 {
25454 if (temp2)
25455 delete arg2;
25456 }
25457 return resultobj;
25458 fail:
25459 {
25460 if (temp2)
25461 delete arg2;
25462 }
25463 return NULL;
25464 }
25465
25466
25467 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj;
25469 wxWindow *arg1 = (wxWindow *) 0 ;
25470 wxString result;
25471 PyObject * obj0 = 0 ;
25472 char *kwnames[] = {
25473 (char *) "self", NULL
25474 };
25475
25476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25478 if (SWIG_arg_fail(1)) SWIG_fail;
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = ((wxWindow const *)arg1)->GetName();
25482
25483 wxPyEndAllowThreads(__tstate);
25484 if (PyErr_Occurred()) SWIG_fail;
25485 }
25486 {
25487 #if wxUSE_UNICODE
25488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25489 #else
25490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25491 #endif
25492 }
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj;
25501 wxWindow *arg1 = (wxWindow *) 0 ;
25502 wxWindowVariant arg2 ;
25503 PyObject * obj0 = 0 ;
25504 PyObject * obj1 = 0 ;
25505 char *kwnames[] = {
25506 (char *) "self",(char *) "variant", NULL
25507 };
25508
25509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25511 if (SWIG_arg_fail(1)) SWIG_fail;
25512 {
25513 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25514 if (SWIG_arg_fail(2)) SWIG_fail;
25515 }
25516 {
25517 PyThreadState* __tstate = wxPyBeginAllowThreads();
25518 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25519
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 Py_INCREF(Py_None); resultobj = Py_None;
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25531 PyObject *resultobj;
25532 wxWindow *arg1 = (wxWindow *) 0 ;
25533 wxWindowVariant result;
25534 PyObject * obj0 = 0 ;
25535 char *kwnames[] = {
25536 (char *) "self", NULL
25537 };
25538
25539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25541 if (SWIG_arg_fail(1)) SWIG_fail;
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25545
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 resultobj = SWIG_From_int((result));
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj;
25558 wxWindow *arg1 = (wxWindow *) 0 ;
25559 int arg2 ;
25560 PyObject * obj0 = 0 ;
25561 PyObject * obj1 = 0 ;
25562 char *kwnames[] = {
25563 (char *) "self",(char *) "winid", NULL
25564 };
25565
25566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25568 if (SWIG_arg_fail(1)) SWIG_fail;
25569 {
25570 arg2 = (int)(SWIG_As_int(obj1));
25571 if (SWIG_arg_fail(2)) SWIG_fail;
25572 }
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 (arg1)->SetId(arg2);
25576
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 Py_INCREF(Py_None); resultobj = Py_None;
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25588 PyObject *resultobj;
25589 wxWindow *arg1 = (wxWindow *) 0 ;
25590 int result;
25591 PyObject * obj0 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "self", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25598 if (SWIG_arg_fail(1)) SWIG_fail;
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 result = (int)((wxWindow const *)arg1)->GetId();
25602
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 {
25607 resultobj = SWIG_From_int((int)(result));
25608 }
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 int result;
25618 char *kwnames[] = {
25619 NULL
25620 };
25621
25622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = (int)wxWindow::NewControlId();
25626
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 resultobj = SWIG_From_int((int)(result));
25632 }
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj;
25641 int arg1 ;
25642 int result;
25643 PyObject * obj0 = 0 ;
25644 char *kwnames[] = {
25645 (char *) "winid", NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25649 {
25650 arg1 = (int)(SWIG_As_int(obj0));
25651 if (SWIG_arg_fail(1)) SWIG_fail;
25652 }
25653 {
25654 PyThreadState* __tstate = wxPyBeginAllowThreads();
25655 result = (int)wxWindow::NextControlId(arg1);
25656
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 {
25661 resultobj = SWIG_From_int((int)(result));
25662 }
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 int arg1 ;
25672 int result;
25673 PyObject * obj0 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "winid", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25679 {
25680 arg1 = (int)(SWIG_As_int(obj0));
25681 if (SWIG_arg_fail(1)) SWIG_fail;
25682 }
25683 {
25684 PyThreadState* __tstate = wxPyBeginAllowThreads();
25685 result = (int)wxWindow::PrevControlId(arg1);
25686
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 resultobj = SWIG_From_int((int)(result));
25692 }
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25700 PyObject *resultobj;
25701 wxWindow *arg1 = (wxWindow *) 0 ;
25702 wxSize *arg2 = 0 ;
25703 wxSize temp2 ;
25704 PyObject * obj0 = 0 ;
25705 PyObject * obj1 = 0 ;
25706 char *kwnames[] = {
25707 (char *) "self",(char *) "size", NULL
25708 };
25709
25710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25712 if (SWIG_arg_fail(1)) SWIG_fail;
25713 {
25714 arg2 = &temp2;
25715 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25716 }
25717 {
25718 PyThreadState* __tstate = wxPyBeginAllowThreads();
25719 (arg1)->SetSize((wxSize const &)*arg2);
25720
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 Py_INCREF(Py_None); resultobj = Py_None;
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25732 PyObject *resultobj;
25733 wxWindow *arg1 = (wxWindow *) 0 ;
25734 int arg2 ;
25735 int arg3 ;
25736 int arg4 ;
25737 int arg5 ;
25738 int arg6 = (int) wxSIZE_AUTO ;
25739 PyObject * obj0 = 0 ;
25740 PyObject * obj1 = 0 ;
25741 PyObject * obj2 = 0 ;
25742 PyObject * obj3 = 0 ;
25743 PyObject * obj4 = 0 ;
25744 PyObject * obj5 = 0 ;
25745 char *kwnames[] = {
25746 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25747 };
25748
25749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25751 if (SWIG_arg_fail(1)) SWIG_fail;
25752 {
25753 arg2 = (int)(SWIG_As_int(obj1));
25754 if (SWIG_arg_fail(2)) SWIG_fail;
25755 }
25756 {
25757 arg3 = (int)(SWIG_As_int(obj2));
25758 if (SWIG_arg_fail(3)) SWIG_fail;
25759 }
25760 {
25761 arg4 = (int)(SWIG_As_int(obj3));
25762 if (SWIG_arg_fail(4)) SWIG_fail;
25763 }
25764 {
25765 arg5 = (int)(SWIG_As_int(obj4));
25766 if (SWIG_arg_fail(5)) SWIG_fail;
25767 }
25768 if (obj5) {
25769 {
25770 arg6 = (int)(SWIG_As_int(obj5));
25771 if (SWIG_arg_fail(6)) SWIG_fail;
25772 }
25773 }
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25777
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 Py_INCREF(Py_None); resultobj = Py_None;
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj;
25790 wxWindow *arg1 = (wxWindow *) 0 ;
25791 wxRect *arg2 = 0 ;
25792 int arg3 = (int) wxSIZE_AUTO ;
25793 wxRect temp2 ;
25794 PyObject * obj0 = 0 ;
25795 PyObject * obj1 = 0 ;
25796 PyObject * obj2 = 0 ;
25797 char *kwnames[] = {
25798 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25799 };
25800
25801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25803 if (SWIG_arg_fail(1)) SWIG_fail;
25804 {
25805 arg2 = &temp2;
25806 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25807 }
25808 if (obj2) {
25809 {
25810 arg3 = (int)(SWIG_As_int(obj2));
25811 if (SWIG_arg_fail(3)) SWIG_fail;
25812 }
25813 }
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25817
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 Py_INCREF(Py_None); resultobj = Py_None;
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj;
25830 wxWindow *arg1 = (wxWindow *) 0 ;
25831 int arg2 ;
25832 int arg3 ;
25833 PyObject * obj0 = 0 ;
25834 PyObject * obj1 = 0 ;
25835 PyObject * obj2 = 0 ;
25836 char *kwnames[] = {
25837 (char *) "self",(char *) "width",(char *) "height", NULL
25838 };
25839
25840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(1)) SWIG_fail;
25843 {
25844 arg2 = (int)(SWIG_As_int(obj1));
25845 if (SWIG_arg_fail(2)) SWIG_fail;
25846 }
25847 {
25848 arg3 = (int)(SWIG_As_int(obj2));
25849 if (SWIG_arg_fail(3)) SWIG_fail;
25850 }
25851 {
25852 PyThreadState* __tstate = wxPyBeginAllowThreads();
25853 (arg1)->SetSize(arg2,arg3);
25854
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 Py_INCREF(Py_None); resultobj = Py_None;
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj;
25867 wxWindow *arg1 = (wxWindow *) 0 ;
25868 wxPoint *arg2 = 0 ;
25869 int arg3 = (int) wxSIZE_USE_EXISTING ;
25870 wxPoint temp2 ;
25871 PyObject * obj0 = 0 ;
25872 PyObject * obj1 = 0 ;
25873 PyObject * obj2 = 0 ;
25874 char *kwnames[] = {
25875 (char *) "self",(char *) "pt",(char *) "flags", NULL
25876 };
25877
25878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25880 if (SWIG_arg_fail(1)) SWIG_fail;
25881 {
25882 arg2 = &temp2;
25883 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25884 }
25885 if (obj2) {
25886 {
25887 arg3 = (int)(SWIG_As_int(obj2));
25888 if (SWIG_arg_fail(3)) SWIG_fail;
25889 }
25890 }
25891 {
25892 PyThreadState* __tstate = wxPyBeginAllowThreads();
25893 (arg1)->Move((wxPoint const &)*arg2,arg3);
25894
25895 wxPyEndAllowThreads(__tstate);
25896 if (PyErr_Occurred()) SWIG_fail;
25897 }
25898 Py_INCREF(Py_None); resultobj = Py_None;
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj;
25907 wxWindow *arg1 = (wxWindow *) 0 ;
25908 int arg2 ;
25909 int arg3 ;
25910 int arg4 = (int) wxSIZE_USE_EXISTING ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 PyObject * obj2 = 0 ;
25914 PyObject * obj3 = 0 ;
25915 char *kwnames[] = {
25916 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25917 };
25918
25919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25921 if (SWIG_arg_fail(1)) SWIG_fail;
25922 {
25923 arg2 = (int)(SWIG_As_int(obj1));
25924 if (SWIG_arg_fail(2)) SWIG_fail;
25925 }
25926 {
25927 arg3 = (int)(SWIG_As_int(obj2));
25928 if (SWIG_arg_fail(3)) SWIG_fail;
25929 }
25930 if (obj3) {
25931 {
25932 arg4 = (int)(SWIG_As_int(obj3));
25933 if (SWIG_arg_fail(4)) SWIG_fail;
25934 }
25935 }
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 (arg1)->Move(arg2,arg3,arg4);
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 Py_INCREF(Py_None); resultobj = Py_None;
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 wxWindow *arg1 = (wxWindow *) 0 ;
25953 wxSize const &arg2_defvalue = wxDefaultSize ;
25954 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25955 wxSize temp2 ;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char *kwnames[] = {
25959 (char *) "self",(char *) "size", NULL
25960 };
25961
25962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25964 if (SWIG_arg_fail(1)) SWIG_fail;
25965 if (obj1) {
25966 {
25967 arg2 = &temp2;
25968 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25969 }
25970 }
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25974
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 Py_INCREF(Py_None); resultobj = Py_None;
25979 return resultobj;
25980 fail:
25981 return NULL;
25982 }
25983
25984
25985 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25986 PyObject *resultobj;
25987 wxWindow *arg1 = (wxWindow *) 0 ;
25988 PyObject * obj0 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 PyThreadState* __tstate = wxPyBeginAllowThreads();
25998 (arg1)->Raise();
25999
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 Py_INCREF(Py_None); resultobj = Py_None;
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj;
26012 wxWindow *arg1 = (wxWindow *) 0 ;
26013 PyObject * obj0 = 0 ;
26014 char *kwnames[] = {
26015 (char *) "self", NULL
26016 };
26017
26018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26020 if (SWIG_arg_fail(1)) SWIG_fail;
26021 {
26022 PyThreadState* __tstate = wxPyBeginAllowThreads();
26023 (arg1)->Lower();
26024
26025 wxPyEndAllowThreads(__tstate);
26026 if (PyErr_Occurred()) SWIG_fail;
26027 }
26028 Py_INCREF(Py_None); resultobj = Py_None;
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj;
26037 wxWindow *arg1 = (wxWindow *) 0 ;
26038 wxSize *arg2 = 0 ;
26039 wxSize temp2 ;
26040 PyObject * obj0 = 0 ;
26041 PyObject * obj1 = 0 ;
26042 char *kwnames[] = {
26043 (char *) "self",(char *) "size", NULL
26044 };
26045
26046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26048 if (SWIG_arg_fail(1)) SWIG_fail;
26049 {
26050 arg2 = &temp2;
26051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26052 }
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 (arg1)->SetClientSize((wxSize const &)*arg2);
26056
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 Py_INCREF(Py_None); resultobj = Py_None;
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj;
26069 wxWindow *arg1 = (wxWindow *) 0 ;
26070 int arg2 ;
26071 int arg3 ;
26072 PyObject * obj0 = 0 ;
26073 PyObject * obj1 = 0 ;
26074 PyObject * obj2 = 0 ;
26075 char *kwnames[] = {
26076 (char *) "self",(char *) "width",(char *) "height", NULL
26077 };
26078
26079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 {
26083 arg2 = (int)(SWIG_As_int(obj1));
26084 if (SWIG_arg_fail(2)) SWIG_fail;
26085 }
26086 {
26087 arg3 = (int)(SWIG_As_int(obj2));
26088 if (SWIG_arg_fail(3)) SWIG_fail;
26089 }
26090 {
26091 PyThreadState* __tstate = wxPyBeginAllowThreads();
26092 (arg1)->SetClientSize(arg2,arg3);
26093
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 Py_INCREF(Py_None); resultobj = Py_None;
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 wxRect *arg2 = 0 ;
26108 wxRect temp2 ;
26109 PyObject * obj0 = 0 ;
26110 PyObject * obj1 = 0 ;
26111 char *kwnames[] = {
26112 (char *) "self",(char *) "rect", NULL
26113 };
26114
26115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26117 if (SWIG_arg_fail(1)) SWIG_fail;
26118 {
26119 arg2 = &temp2;
26120 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 (arg1)->SetClientSize((wxRect const &)*arg2);
26125
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 Py_INCREF(Py_None); resultobj = Py_None;
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj;
26138 wxWindow *arg1 = (wxWindow *) 0 ;
26139 wxPoint result;
26140 PyObject * obj0 = 0 ;
26141 char *kwnames[] = {
26142 (char *) "self", NULL
26143 };
26144
26145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26147 if (SWIG_arg_fail(1)) SWIG_fail;
26148 {
26149 PyThreadState* __tstate = wxPyBeginAllowThreads();
26150 result = (arg1)->GetPosition();
26151
26152 wxPyEndAllowThreads(__tstate);
26153 if (PyErr_Occurred()) SWIG_fail;
26154 }
26155 {
26156 wxPoint * resultptr;
26157 resultptr = new wxPoint((wxPoint &)(result));
26158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26159 }
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26167 PyObject *resultobj;
26168 wxWindow *arg1 = (wxWindow *) 0 ;
26169 int *arg2 = (int *) 0 ;
26170 int *arg3 = (int *) 0 ;
26171 int temp2 ;
26172 int res2 = 0 ;
26173 int temp3 ;
26174 int res3 = 0 ;
26175 PyObject * obj0 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self", NULL
26178 };
26179
26180 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26181 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26184 if (SWIG_arg_fail(1)) SWIG_fail;
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 (arg1)->GetPosition(arg2,arg3);
26188
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 Py_INCREF(Py_None); resultobj = Py_None;
26193 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26194 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26195 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26196 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26197 return resultobj;
26198 fail:
26199 return NULL;
26200 }
26201
26202
26203 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26204 PyObject *resultobj;
26205 wxWindow *arg1 = (wxWindow *) 0 ;
26206 wxSize result;
26207 PyObject * obj0 = 0 ;
26208 char *kwnames[] = {
26209 (char *) "self", NULL
26210 };
26211
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26214 if (SWIG_arg_fail(1)) SWIG_fail;
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 result = ((wxWindow const *)arg1)->GetSize();
26218
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 {
26223 wxSize * resultptr;
26224 resultptr = new wxSize((wxSize &)(result));
26225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26226 }
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj;
26235 wxWindow *arg1 = (wxWindow *) 0 ;
26236 int *arg2 = (int *) 0 ;
26237 int *arg3 = (int *) 0 ;
26238 int temp2 ;
26239 int res2 = 0 ;
26240 int temp3 ;
26241 int res3 = 0 ;
26242 PyObject * obj0 = 0 ;
26243 char *kwnames[] = {
26244 (char *) "self", NULL
26245 };
26246
26247 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26248 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26251 if (SWIG_arg_fail(1)) SWIG_fail;
26252 {
26253 PyThreadState* __tstate = wxPyBeginAllowThreads();
26254 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26255
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 Py_INCREF(Py_None); resultobj = Py_None;
26260 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26261 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26262 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26263 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj;
26272 wxWindow *arg1 = (wxWindow *) 0 ;
26273 wxRect result;
26274 PyObject * obj0 = 0 ;
26275 char *kwnames[] = {
26276 (char *) "self", NULL
26277 };
26278
26279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26281 if (SWIG_arg_fail(1)) SWIG_fail;
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = ((wxWindow const *)arg1)->GetRect();
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 {
26290 wxRect * resultptr;
26291 resultptr = new wxRect((wxRect &)(result));
26292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26293 }
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj;
26302 wxWindow *arg1 = (wxWindow *) 0 ;
26303 wxSize result;
26304 PyObject * obj0 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "self", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26311 if (SWIG_arg_fail(1)) SWIG_fail;
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = ((wxWindow const *)arg1)->GetClientSize();
26315
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 {
26320 wxSize * resultptr;
26321 resultptr = new wxSize((wxSize &)(result));
26322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26323 }
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26331 PyObject *resultobj;
26332 wxWindow *arg1 = (wxWindow *) 0 ;
26333 int *arg2 = (int *) 0 ;
26334 int *arg3 = (int *) 0 ;
26335 int temp2 ;
26336 int res2 = 0 ;
26337 int temp3 ;
26338 int res3 = 0 ;
26339 PyObject * obj0 = 0 ;
26340 char *kwnames[] = {
26341 (char *) "self", NULL
26342 };
26343
26344 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26345 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26348 if (SWIG_arg_fail(1)) SWIG_fail;
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26352
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 Py_INCREF(Py_None); resultobj = Py_None;
26357 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26358 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26359 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26360 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj;
26369 wxWindow *arg1 = (wxWindow *) 0 ;
26370 wxPoint result;
26371 PyObject * obj0 = 0 ;
26372 char *kwnames[] = {
26373 (char *) "self", NULL
26374 };
26375
26376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26378 if (SWIG_arg_fail(1)) SWIG_fail;
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26382
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 {
26387 wxPoint * resultptr;
26388 resultptr = new wxPoint((wxPoint &)(result));
26389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26390 }
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 wxRect result;
26401 PyObject * obj0 = 0 ;
26402 char *kwnames[] = {
26403 (char *) "self", NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(1)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = ((wxWindow const *)arg1)->GetClientRect();
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 wxRect * resultptr;
26418 resultptr = new wxRect((wxRect &)(result));
26419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26420 }
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj;
26429 wxWindow *arg1 = (wxWindow *) 0 ;
26430 wxSize result;
26431 PyObject * obj0 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = ((wxWindow const *)arg1)->GetBestSize();
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 {
26447 wxSize * resultptr;
26448 resultptr = new wxSize((wxSize &)(result));
26449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26450 }
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 int *arg2 = (int *) 0 ;
26461 int *arg3 = (int *) 0 ;
26462 int temp2 ;
26463 int res2 = 0 ;
26464 int temp3 ;
26465 int res3 = 0 ;
26466 PyObject * obj0 = 0 ;
26467 char *kwnames[] = {
26468 (char *) "self", NULL
26469 };
26470
26471 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26472 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26475 if (SWIG_arg_fail(1)) SWIG_fail;
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 Py_INCREF(Py_None); resultobj = Py_None;
26484 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26485 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26486 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26487 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 PyObject * obj0 = 0 ;
26498 char *kwnames[] = {
26499 (char *) "self", NULL
26500 };
26501
26502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26504 if (SWIG_arg_fail(1)) SWIG_fail;
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 (arg1)->InvalidateBestSize();
26508
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 Py_INCREF(Py_None); resultobj = Py_None;
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj;
26521 wxWindow *arg1 = (wxWindow *) 0 ;
26522 wxSize result;
26523 PyObject * obj0 = 0 ;
26524 char *kwnames[] = {
26525 (char *) "self", NULL
26526 };
26527
26528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26530 if (SWIG_arg_fail(1)) SWIG_fail;
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26534
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 wxSize * resultptr;
26540 resultptr = new wxSize((wxSize &)(result));
26541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26542 }
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26550 PyObject *resultobj;
26551 wxWindow *arg1 = (wxWindow *) 0 ;
26552 wxSize result;
26553 PyObject * obj0 = 0 ;
26554 char *kwnames[] = {
26555 (char *) "self", NULL
26556 };
26557
26558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26560 if (SWIG_arg_fail(1)) SWIG_fail;
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 {
26569 wxSize * resultptr;
26570 resultptr = new wxSize((wxSize &)(result));
26571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26572 }
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26580 PyObject *resultobj;
26581 wxWindow *arg1 = (wxWindow *) 0 ;
26582 int arg2 = (int) wxBOTH ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char *kwnames[] = {
26586 (char *) "self",(char *) "direction", NULL
26587 };
26588
26589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26591 if (SWIG_arg_fail(1)) SWIG_fail;
26592 if (obj1) {
26593 {
26594 arg2 = (int)(SWIG_As_int(obj1));
26595 if (SWIG_arg_fail(2)) SWIG_fail;
26596 }
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 (arg1)->Center(arg2);
26601
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 Py_INCREF(Py_None); resultobj = Py_None;
26606 return resultobj;
26607 fail:
26608 return NULL;
26609 }
26610
26611
26612 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26613 PyObject *resultobj;
26614 wxWindow *arg1 = (wxWindow *) 0 ;
26615 int arg2 = (int) wxBOTH ;
26616 PyObject * obj0 = 0 ;
26617 PyObject * obj1 = 0 ;
26618 char *kwnames[] = {
26619 (char *) "self",(char *) "dir", NULL
26620 };
26621
26622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26624 if (SWIG_arg_fail(1)) SWIG_fail;
26625 if (obj1) {
26626 {
26627 arg2 = (int)(SWIG_As_int(obj1));
26628 if (SWIG_arg_fail(2)) SWIG_fail;
26629 }
26630 }
26631 {
26632 PyThreadState* __tstate = wxPyBeginAllowThreads();
26633 (arg1)->CenterOnScreen(arg2);
26634
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 Py_INCREF(Py_None); resultobj = Py_None;
26639 return resultobj;
26640 fail:
26641 return NULL;
26642 }
26643
26644
26645 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26646 PyObject *resultobj;
26647 wxWindow *arg1 = (wxWindow *) 0 ;
26648 int arg2 = (int) wxBOTH ;
26649 PyObject * obj0 = 0 ;
26650 PyObject * obj1 = 0 ;
26651 char *kwnames[] = {
26652 (char *) "self",(char *) "dir", NULL
26653 };
26654
26655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26657 if (SWIG_arg_fail(1)) SWIG_fail;
26658 if (obj1) {
26659 {
26660 arg2 = (int)(SWIG_As_int(obj1));
26661 if (SWIG_arg_fail(2)) SWIG_fail;
26662 }
26663 }
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 (arg1)->CenterOnParent(arg2);
26667
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 Py_INCREF(Py_None); resultobj = Py_None;
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26679 PyObject *resultobj;
26680 wxWindow *arg1 = (wxWindow *) 0 ;
26681 PyObject * obj0 = 0 ;
26682 char *kwnames[] = {
26683 (char *) "self", NULL
26684 };
26685
26686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 (arg1)->Fit();
26692
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 Py_INCREF(Py_None); resultobj = Py_None;
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26704 PyObject *resultobj;
26705 wxWindow *arg1 = (wxWindow *) 0 ;
26706 PyObject * obj0 = 0 ;
26707 char *kwnames[] = {
26708 (char *) "self", NULL
26709 };
26710
26711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(1)) SWIG_fail;
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 (arg1)->FitInside();
26717
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 Py_INCREF(Py_None); resultobj = Py_None;
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26729 PyObject *resultobj;
26730 wxWindow *arg1 = (wxWindow *) 0 ;
26731 int arg2 ;
26732 int arg3 ;
26733 int arg4 = (int) -1 ;
26734 int arg5 = (int) -1 ;
26735 int arg6 = (int) -1 ;
26736 int arg7 = (int) -1 ;
26737 PyObject * obj0 = 0 ;
26738 PyObject * obj1 = 0 ;
26739 PyObject * obj2 = 0 ;
26740 PyObject * obj3 = 0 ;
26741 PyObject * obj4 = 0 ;
26742 PyObject * obj5 = 0 ;
26743 PyObject * obj6 = 0 ;
26744 char *kwnames[] = {
26745 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26746 };
26747
26748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26750 if (SWIG_arg_fail(1)) SWIG_fail;
26751 {
26752 arg2 = (int)(SWIG_As_int(obj1));
26753 if (SWIG_arg_fail(2)) SWIG_fail;
26754 }
26755 {
26756 arg3 = (int)(SWIG_As_int(obj2));
26757 if (SWIG_arg_fail(3)) SWIG_fail;
26758 }
26759 if (obj3) {
26760 {
26761 arg4 = (int)(SWIG_As_int(obj3));
26762 if (SWIG_arg_fail(4)) SWIG_fail;
26763 }
26764 }
26765 if (obj4) {
26766 {
26767 arg5 = (int)(SWIG_As_int(obj4));
26768 if (SWIG_arg_fail(5)) SWIG_fail;
26769 }
26770 }
26771 if (obj5) {
26772 {
26773 arg6 = (int)(SWIG_As_int(obj5));
26774 if (SWIG_arg_fail(6)) SWIG_fail;
26775 }
26776 }
26777 if (obj6) {
26778 {
26779 arg7 = (int)(SWIG_As_int(obj6));
26780 if (SWIG_arg_fail(7)) SWIG_fail;
26781 }
26782 }
26783 {
26784 PyThreadState* __tstate = wxPyBeginAllowThreads();
26785 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26786
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 Py_INCREF(Py_None); resultobj = Py_None;
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26798 PyObject *resultobj;
26799 wxWindow *arg1 = (wxWindow *) 0 ;
26800 wxSize *arg2 = 0 ;
26801 wxSize const &arg3_defvalue = wxDefaultSize ;
26802 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26803 wxSize const &arg4_defvalue = wxDefaultSize ;
26804 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26805 wxSize temp2 ;
26806 wxSize temp3 ;
26807 wxSize temp4 ;
26808 PyObject * obj0 = 0 ;
26809 PyObject * obj1 = 0 ;
26810 PyObject * obj2 = 0 ;
26811 PyObject * obj3 = 0 ;
26812 char *kwnames[] = {
26813 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26814 };
26815
26816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26818 if (SWIG_arg_fail(1)) SWIG_fail;
26819 {
26820 arg2 = &temp2;
26821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26822 }
26823 if (obj2) {
26824 {
26825 arg3 = &temp3;
26826 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26827 }
26828 }
26829 if (obj3) {
26830 {
26831 arg4 = &temp4;
26832 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26833 }
26834 }
26835 {
26836 PyThreadState* __tstate = wxPyBeginAllowThreads();
26837 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26838
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 Py_INCREF(Py_None); resultobj = Py_None;
26843 return resultobj;
26844 fail:
26845 return NULL;
26846 }
26847
26848
26849 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj;
26851 wxWindow *arg1 = (wxWindow *) 0 ;
26852 int arg2 ;
26853 int arg3 ;
26854 int arg4 = (int) -1 ;
26855 int arg5 = (int) -1 ;
26856 PyObject * obj0 = 0 ;
26857 PyObject * obj1 = 0 ;
26858 PyObject * obj2 = 0 ;
26859 PyObject * obj3 = 0 ;
26860 PyObject * obj4 = 0 ;
26861 char *kwnames[] = {
26862 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26863 };
26864
26865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26867 if (SWIG_arg_fail(1)) SWIG_fail;
26868 {
26869 arg2 = (int)(SWIG_As_int(obj1));
26870 if (SWIG_arg_fail(2)) SWIG_fail;
26871 }
26872 {
26873 arg3 = (int)(SWIG_As_int(obj2));
26874 if (SWIG_arg_fail(3)) SWIG_fail;
26875 }
26876 if (obj3) {
26877 {
26878 arg4 = (int)(SWIG_As_int(obj3));
26879 if (SWIG_arg_fail(4)) SWIG_fail;
26880 }
26881 }
26882 if (obj4) {
26883 {
26884 arg5 = (int)(SWIG_As_int(obj4));
26885 if (SWIG_arg_fail(5)) SWIG_fail;
26886 }
26887 }
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26891
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 Py_INCREF(Py_None); resultobj = Py_None;
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj;
26904 wxWindow *arg1 = (wxWindow *) 0 ;
26905 wxSize *arg2 = 0 ;
26906 wxSize const &arg3_defvalue = wxDefaultSize ;
26907 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26908 wxSize temp2 ;
26909 wxSize temp3 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 PyObject * obj2 = 0 ;
26913 char *kwnames[] = {
26914 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26915 };
26916
26917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26919 if (SWIG_arg_fail(1)) SWIG_fail;
26920 {
26921 arg2 = &temp2;
26922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26923 }
26924 if (obj2) {
26925 {
26926 arg3 = &temp3;
26927 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26928 }
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26933
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 Py_INCREF(Py_None); resultobj = Py_None;
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj;
26946 wxWindow *arg1 = (wxWindow *) 0 ;
26947 wxSize result;
26948 PyObject * obj0 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 result = ((wxWindow const *)arg1)->GetMaxSize();
26959
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 {
26964 wxSize * resultptr;
26965 resultptr = new wxSize((wxSize &)(result));
26966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26967 }
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj;
26976 wxWindow *arg1 = (wxWindow *) 0 ;
26977 wxSize result;
26978 PyObject * obj0 = 0 ;
26979 char *kwnames[] = {
26980 (char *) "self", NULL
26981 };
26982
26983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26985 if (SWIG_arg_fail(1)) SWIG_fail;
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 result = ((wxWindow const *)arg1)->GetMinSize();
26989
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 {
26994 wxSize * resultptr;
26995 resultptr = new wxSize((wxSize &)(result));
26996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj;
27006 wxWindow *arg1 = (wxWindow *) 0 ;
27007 wxSize *arg2 = 0 ;
27008 wxSize temp2 ;
27009 PyObject * obj0 = 0 ;
27010 PyObject * obj1 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self",(char *) "minSize", NULL
27013 };
27014
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
27020 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27021 }
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetMinSize((wxSize const &)*arg2);
27025
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 Py_INCREF(Py_None); resultobj = Py_None;
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj;
27038 wxWindow *arg1 = (wxWindow *) 0 ;
27039 wxSize *arg2 = 0 ;
27040 wxSize temp2 ;
27041 PyObject * obj0 = 0 ;
27042 PyObject * obj1 = 0 ;
27043 char *kwnames[] = {
27044 (char *) "self",(char *) "maxSize", NULL
27045 };
27046
27047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27049 if (SWIG_arg_fail(1)) SWIG_fail;
27050 {
27051 arg2 = &temp2;
27052 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27053 }
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 (arg1)->SetMaxSize((wxSize const &)*arg2);
27057
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 Py_INCREF(Py_None); resultobj = Py_None;
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj;
27070 wxWindow *arg1 = (wxWindow *) 0 ;
27071 int result;
27072 PyObject * obj0 = 0 ;
27073 char *kwnames[] = {
27074 (char *) "self", NULL
27075 };
27076
27077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(1)) SWIG_fail;
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27083
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 {
27088 resultobj = SWIG_From_int((int)(result));
27089 }
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 int result;
27100 PyObject * obj0 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = SWIG_From_int((int)(result));
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 int result;
27128 PyObject * obj0 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = SWIG_From_int((int)(result));
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 int result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = SWIG_From_int((int)(result));
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 wxSize *arg2 = 0 ;
27184 wxSize temp2 ;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 char *kwnames[] = {
27188 (char *) "self",(char *) "size", NULL
27189 };
27190
27191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27193 if (SWIG_arg_fail(1)) SWIG_fail;
27194 {
27195 arg2 = &temp2;
27196 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27197 }
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27201
27202 wxPyEndAllowThreads(__tstate);
27203 if (PyErr_Occurred()) SWIG_fail;
27204 }
27205 Py_INCREF(Py_None); resultobj = Py_None;
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxWindow *arg1 = (wxWindow *) 0 ;
27215 int arg2 ;
27216 int arg3 ;
27217 PyObject * obj0 = 0 ;
27218 PyObject * obj1 = 0 ;
27219 PyObject * obj2 = 0 ;
27220 char *kwnames[] = {
27221 (char *) "self",(char *) "w",(char *) "h", NULL
27222 };
27223
27224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27226 if (SWIG_arg_fail(1)) SWIG_fail;
27227 {
27228 arg2 = (int)(SWIG_As_int(obj1));
27229 if (SWIG_arg_fail(2)) SWIG_fail;
27230 }
27231 {
27232 arg3 = (int)(SWIG_As_int(obj2));
27233 if (SWIG_arg_fail(3)) SWIG_fail;
27234 }
27235 {
27236 PyThreadState* __tstate = wxPyBeginAllowThreads();
27237 (arg1)->SetVirtualSize(arg2,arg3);
27238
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 Py_INCREF(Py_None); resultobj = Py_None;
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27250 PyObject *resultobj;
27251 wxWindow *arg1 = (wxWindow *) 0 ;
27252 wxSize result;
27253 PyObject * obj0 = 0 ;
27254 char *kwnames[] = {
27255 (char *) "self", NULL
27256 };
27257
27258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27260 if (SWIG_arg_fail(1)) SWIG_fail;
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 result = ((wxWindow const *)arg1)->GetVirtualSize();
27264
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 {
27269 wxSize * resultptr;
27270 resultptr = new wxSize((wxSize &)(result));
27271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27272 }
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27280 PyObject *resultobj;
27281 wxWindow *arg1 = (wxWindow *) 0 ;
27282 int *arg2 = (int *) 0 ;
27283 int *arg3 = (int *) 0 ;
27284 int temp2 ;
27285 int res2 = 0 ;
27286 int temp3 ;
27287 int res3 = 0 ;
27288 PyObject * obj0 = 0 ;
27289 char *kwnames[] = {
27290 (char *) "self", NULL
27291 };
27292
27293 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27294 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) 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 {
27299 PyThreadState* __tstate = wxPyBeginAllowThreads();
27300 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27301
27302 wxPyEndAllowThreads(__tstate);
27303 if (PyErr_Occurred()) SWIG_fail;
27304 }
27305 Py_INCREF(Py_None); resultobj = Py_None;
27306 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27307 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27308 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27309 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27317 PyObject *resultobj;
27318 wxWindow *arg1 = (wxWindow *) 0 ;
27319 wxSize result;
27320 PyObject * obj0 = 0 ;
27321 char *kwnames[] = {
27322 (char *) "self", NULL
27323 };
27324
27325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27327 if (SWIG_arg_fail(1)) SWIG_fail;
27328 {
27329 PyThreadState* __tstate = wxPyBeginAllowThreads();
27330 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27331
27332 wxPyEndAllowThreads(__tstate);
27333 if (PyErr_Occurred()) SWIG_fail;
27334 }
27335 {
27336 wxSize * resultptr;
27337 resultptr = new wxSize((wxSize &)(result));
27338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27347 PyObject *resultobj;
27348 wxWindow *arg1 = (wxWindow *) 0 ;
27349 bool arg2 = (bool) true ;
27350 bool result;
27351 PyObject * obj0 = 0 ;
27352 PyObject * obj1 = 0 ;
27353 char *kwnames[] = {
27354 (char *) "self",(char *) "show", NULL
27355 };
27356
27357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27359 if (SWIG_arg_fail(1)) SWIG_fail;
27360 if (obj1) {
27361 {
27362 arg2 = (bool)(SWIG_As_bool(obj1));
27363 if (SWIG_arg_fail(2)) SWIG_fail;
27364 }
27365 }
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = (bool)(arg1)->Show(arg2);
27369
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj;
27384 wxWindow *arg1 = (wxWindow *) 0 ;
27385 bool result;
27386 PyObject * obj0 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 result = (bool)(arg1)->Hide();
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 {
27402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27403 }
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj;
27412 wxWindow *arg1 = (wxWindow *) 0 ;
27413 bool arg2 = (bool) true ;
27414 bool result;
27415 PyObject * obj0 = 0 ;
27416 PyObject * obj1 = 0 ;
27417 char *kwnames[] = {
27418 (char *) "self",(char *) "enable", NULL
27419 };
27420
27421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) 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 if (obj1) {
27425 {
27426 arg2 = (bool)(SWIG_As_bool(obj1));
27427 if (SWIG_arg_fail(2)) SWIG_fail;
27428 }
27429 }
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 result = (bool)(arg1)->Enable(arg2);
27433
27434 wxPyEndAllowThreads(__tstate);
27435 if (PyErr_Occurred()) SWIG_fail;
27436 }
27437 {
27438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27439 }
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj;
27448 wxWindow *arg1 = (wxWindow *) 0 ;
27449 bool result;
27450 PyObject * obj0 = 0 ;
27451 char *kwnames[] = {
27452 (char *) "self", NULL
27453 };
27454
27455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27457 if (SWIG_arg_fail(1)) SWIG_fail;
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)(arg1)->Disable();
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxWindow *arg1 = (wxWindow *) 0 ;
27477 bool result;
27478 PyObject * obj0 = 0 ;
27479 char *kwnames[] = {
27480 (char *) "self", NULL
27481 };
27482
27483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27485 if (SWIG_arg_fail(1)) SWIG_fail;
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)((wxWindow const *)arg1)->IsShown();
27489
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 {
27494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27495 }
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27503 PyObject *resultobj;
27504 wxWindow *arg1 = (wxWindow *) 0 ;
27505 bool result;
27506 PyObject * obj0 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27517
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 {
27522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27523 }
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxWindow *arg1 = (wxWindow *) 0 ;
27533 long arg2 ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 char *kwnames[] = {
27537 (char *) "self",(char *) "style", NULL
27538 };
27539
27540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27542 if (SWIG_arg_fail(1)) SWIG_fail;
27543 {
27544 arg2 = (long)(SWIG_As_long(obj1));
27545 if (SWIG_arg_fail(2)) SWIG_fail;
27546 }
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->SetWindowStyleFlag(arg2);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 Py_INCREF(Py_None); resultobj = Py_None;
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj;
27563 wxWindow *arg1 = (wxWindow *) 0 ;
27564 long result;
27565 PyObject * obj0 = 0 ;
27566 char *kwnames[] = {
27567 (char *) "self", NULL
27568 };
27569
27570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",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 = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27576
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 {
27581 resultobj = SWIG_From_long((long)(result));
27582 }
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxWindow *arg1 = (wxWindow *) 0 ;
27592 int arg2 ;
27593 bool result;
27594 PyObject * obj0 = 0 ;
27595 PyObject * obj1 = 0 ;
27596 char *kwnames[] = {
27597 (char *) "self",(char *) "flag", NULL
27598 };
27599
27600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27602 if (SWIG_arg_fail(1)) SWIG_fail;
27603 {
27604 arg2 = (int)(SWIG_As_int(obj1));
27605 if (SWIG_arg_fail(2)) SWIG_fail;
27606 }
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27610
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 {
27615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27616 }
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27624 PyObject *resultobj;
27625 wxWindow *arg1 = (wxWindow *) 0 ;
27626 bool result;
27627 PyObject * obj0 = 0 ;
27628 char *kwnames[] = {
27629 (char *) "self", NULL
27630 };
27631
27632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27634 if (SWIG_arg_fail(1)) SWIG_fail;
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (bool)((wxWindow const *)arg1)->IsRetained();
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxWindow *arg1 = (wxWindow *) 0 ;
27654 long arg2 ;
27655 PyObject * obj0 = 0 ;
27656 PyObject * obj1 = 0 ;
27657 char *kwnames[] = {
27658 (char *) "self",(char *) "exStyle", NULL
27659 };
27660
27661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27663 if (SWIG_arg_fail(1)) SWIG_fail;
27664 {
27665 arg2 = (long)(SWIG_As_long(obj1));
27666 if (SWIG_arg_fail(2)) SWIG_fail;
27667 }
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 (arg1)->SetExtraStyle(arg2);
27671
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 Py_INCREF(Py_None); resultobj = Py_None;
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27683 PyObject *resultobj;
27684 wxWindow *arg1 = (wxWindow *) 0 ;
27685 long result;
27686 PyObject * obj0 = 0 ;
27687 char *kwnames[] = {
27688 (char *) "self", NULL
27689 };
27690
27691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27697
27698 wxPyEndAllowThreads(__tstate);
27699 if (PyErr_Occurred()) SWIG_fail;
27700 }
27701 {
27702 resultobj = SWIG_From_long((long)(result));
27703 }
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27711 PyObject *resultobj;
27712 wxWindow *arg1 = (wxWindow *) 0 ;
27713 bool arg2 = (bool) true ;
27714 PyObject * obj0 = 0 ;
27715 PyObject * obj1 = 0 ;
27716 char *kwnames[] = {
27717 (char *) "self",(char *) "modal", NULL
27718 };
27719
27720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27722 if (SWIG_arg_fail(1)) SWIG_fail;
27723 if (obj1) {
27724 {
27725 arg2 = (bool)(SWIG_As_bool(obj1));
27726 if (SWIG_arg_fail(2)) SWIG_fail;
27727 }
27728 }
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 (arg1)->MakeModal(arg2);
27732
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 Py_INCREF(Py_None); resultobj = Py_None;
27737 return resultobj;
27738 fail:
27739 return NULL;
27740 }
27741
27742
27743 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27744 PyObject *resultobj;
27745 wxWindow *arg1 = (wxWindow *) 0 ;
27746 bool arg2 ;
27747 PyObject * obj0 = 0 ;
27748 PyObject * obj1 = 0 ;
27749 char *kwnames[] = {
27750 (char *) "self",(char *) "enableTheme", NULL
27751 };
27752
27753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27755 if (SWIG_arg_fail(1)) SWIG_fail;
27756 {
27757 arg2 = (bool)(SWIG_As_bool(obj1));
27758 if (SWIG_arg_fail(2)) SWIG_fail;
27759 }
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 (arg1)->SetThemeEnabled(arg2);
27763
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 Py_INCREF(Py_None); resultobj = Py_None;
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27775 PyObject *resultobj;
27776 wxWindow *arg1 = (wxWindow *) 0 ;
27777 bool result;
27778 PyObject * obj0 = 0 ;
27779 char *kwnames[] = {
27780 (char *) "self", NULL
27781 };
27782
27783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27785 if (SWIG_arg_fail(1)) SWIG_fail;
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27789
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 {
27794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj;
27804 wxWindow *arg1 = (wxWindow *) 0 ;
27805 PyObject * obj0 = 0 ;
27806 char *kwnames[] = {
27807 (char *) "self", NULL
27808 };
27809
27810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(1)) SWIG_fail;
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 (arg1)->SetFocus();
27816
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 Py_INCREF(Py_None); resultobj = Py_None;
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27828 PyObject *resultobj;
27829 wxWindow *arg1 = (wxWindow *) 0 ;
27830 PyObject * obj0 = 0 ;
27831 char *kwnames[] = {
27832 (char *) "self", NULL
27833 };
27834
27835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(1)) SWIG_fail;
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 (arg1)->SetFocusFromKbd();
27841
27842 wxPyEndAllowThreads(__tstate);
27843 if (PyErr_Occurred()) SWIG_fail;
27844 }
27845 Py_INCREF(Py_None); resultobj = Py_None;
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj;
27854 wxWindow *result;
27855 char *kwnames[] = {
27856 NULL
27857 };
27858
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27860 {
27861 if (!wxPyCheckForApp()) SWIG_fail;
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (wxWindow *)wxWindow::FindFocus();
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 {
27869 resultobj = wxPyMake_wxObject(result, 0);
27870 }
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27878 PyObject *resultobj;
27879 wxWindow *arg1 = (wxWindow *) 0 ;
27880 bool result;
27881 PyObject * obj0 = 0 ;
27882 char *kwnames[] = {
27883 (char *) "self", NULL
27884 };
27885
27886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27888 if (SWIG_arg_fail(1)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 bool result;
27909 PyObject * obj0 = 0 ;
27910 char *kwnames[] = {
27911 (char *) "self", NULL
27912 };
27913
27914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 wxWindow *result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = wxPyMake_wxObject(result, 0);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxWindow *arg2 = (wxWindow *) 0 ;
27965 wxWindow *result;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968 char *kwnames[] = {
27969 (char *) "self",(char *) "child", NULL
27970 };
27971
27972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(1)) SWIG_fail;
27975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(2)) SWIG_fail;
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 resultobj = wxPyMake_wxObject(result, 0);
27986 }
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxWindow *arg2 = (wxWindow *) 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char *kwnames[] = {
28000 (char *) "self",(char *) "win", NULL
28001 };
28002
28003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28005 if (SWIG_arg_fail(1)) SWIG_fail;
28006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28007 if (SWIG_arg_fail(2)) SWIG_fail;
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->SetTmpDefaultItem(arg2);
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 Py_INCREF(Py_None); resultobj = Py_None;
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj;
28024 wxWindow *arg1 = (wxWindow *) 0 ;
28025 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28026 bool result;
28027 PyObject * obj0 = 0 ;
28028 PyObject * obj1 = 0 ;
28029 char *kwnames[] = {
28030 (char *) "self",(char *) "flags", NULL
28031 };
28032
28033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28035 if (SWIG_arg_fail(1)) SWIG_fail;
28036 if (obj1) {
28037 {
28038 arg2 = (int)(SWIG_As_int(obj1));
28039 if (SWIG_arg_fail(2)) SWIG_fail;
28040 }
28041 }
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 result = (bool)(arg1)->Navigate(arg2);
28045
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 {
28050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28051 }
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj;
28060 wxWindow *arg1 = (wxWindow *) 0 ;
28061 wxWindow *arg2 = (wxWindow *) 0 ;
28062 PyObject * obj0 = 0 ;
28063 PyObject * obj1 = 0 ;
28064 char *kwnames[] = {
28065 (char *) "self",(char *) "win", NULL
28066 };
28067
28068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28070 if (SWIG_arg_fail(1)) SWIG_fail;
28071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28072 if (SWIG_arg_fail(2)) SWIG_fail;
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 (arg1)->MoveAfterInTabOrder(arg2);
28076
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 Py_INCREF(Py_None); resultobj = Py_None;
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj;
28089 wxWindow *arg1 = (wxWindow *) 0 ;
28090 wxWindow *arg2 = (wxWindow *) 0 ;
28091 PyObject * obj0 = 0 ;
28092 PyObject * obj1 = 0 ;
28093 char *kwnames[] = {
28094 (char *) "self",(char *) "win", NULL
28095 };
28096
28097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28099 if (SWIG_arg_fail(1)) SWIG_fail;
28100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28101 if (SWIG_arg_fail(2)) SWIG_fail;
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 (arg1)->MoveBeforeInTabOrder(arg2);
28105
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 Py_INCREF(Py_None); resultobj = Py_None;
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28117 PyObject *resultobj;
28118 wxWindow *arg1 = (wxWindow *) 0 ;
28119 PyObject *result;
28120 PyObject * obj0 = 0 ;
28121 char *kwnames[] = {
28122 (char *) "self", NULL
28123 };
28124
28125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28127 if (SWIG_arg_fail(1)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (PyObject *)wxWindow_GetChildren(arg1);
28131
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = result;
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj;
28144 wxWindow *arg1 = (wxWindow *) 0 ;
28145 wxWindow *result;
28146 PyObject * obj0 = 0 ;
28147 char *kwnames[] = {
28148 (char *) "self", NULL
28149 };
28150
28151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28153 if (SWIG_arg_fail(1)) SWIG_fail;
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28157
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 {
28162 resultobj = wxPyMake_wxObject(result, 0);
28163 }
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28171 PyObject *resultobj;
28172 wxWindow *arg1 = (wxWindow *) 0 ;
28173 wxWindow *result;
28174 PyObject * obj0 = 0 ;
28175 char *kwnames[] = {
28176 (char *) "self", NULL
28177 };
28178
28179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28181 if (SWIG_arg_fail(1)) SWIG_fail;
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28185
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 {
28190 resultobj = wxPyMake_wxObject(result, 0);
28191 }
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj;
28200 wxWindow *arg1 = (wxWindow *) 0 ;
28201 bool result;
28202 PyObject * obj0 = 0 ;
28203 char *kwnames[] = {
28204 (char *) "self", NULL
28205 };
28206
28207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28209 if (SWIG_arg_fail(1)) SWIG_fail;
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28213
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj;
28228 wxWindow *arg1 = (wxWindow *) 0 ;
28229 wxWindow *arg2 = (wxWindow *) 0 ;
28230 bool result;
28231 PyObject * obj0 = 0 ;
28232 PyObject * obj1 = 0 ;
28233 char *kwnames[] = {
28234 (char *) "self",(char *) "newParent", NULL
28235 };
28236
28237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28239 if (SWIG_arg_fail(1)) SWIG_fail;
28240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(2)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (bool)(arg1)->Reparent(arg2);
28245
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxWindow *arg1 = (wxWindow *) 0 ;
28261 wxWindow *arg2 = (wxWindow *) 0 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char *kwnames[] = {
28265 (char *) "self",(char *) "child", NULL
28266 };
28267
28268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28270 if (SWIG_arg_fail(1)) SWIG_fail;
28271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28272 if (SWIG_arg_fail(2)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 (arg1)->AddChild(arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 Py_INCREF(Py_None); resultobj = Py_None;
28281 return resultobj;
28282 fail:
28283 return NULL;
28284 }
28285
28286
28287 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28288 PyObject *resultobj;
28289 wxWindow *arg1 = (wxWindow *) 0 ;
28290 wxWindow *arg2 = (wxWindow *) 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char *kwnames[] = {
28294 (char *) "self",(char *) "child", NULL
28295 };
28296
28297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28299 if (SWIG_arg_fail(1)) SWIG_fail;
28300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(2)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 (arg1)->RemoveChild(arg2);
28305
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 Py_INCREF(Py_None); resultobj = Py_None;
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj;
28318 wxWindow *arg1 = (wxWindow *) 0 ;
28319 long arg2 ;
28320 wxWindow *result;
28321 PyObject * obj0 = 0 ;
28322 PyObject * obj1 = 0 ;
28323 char *kwnames[] = {
28324 (char *) "self",(char *) "winid", NULL
28325 };
28326
28327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28329 if (SWIG_arg_fail(1)) SWIG_fail;
28330 {
28331 arg2 = (long)(SWIG_As_long(obj1));
28332 if (SWIG_arg_fail(2)) SWIG_fail;
28333 }
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (wxWindow *)(arg1)->FindWindow(arg2);
28337
28338 wxPyEndAllowThreads(__tstate);
28339 if (PyErr_Occurred()) SWIG_fail;
28340 }
28341 {
28342 resultobj = wxPyMake_wxObject(result, 0);
28343 }
28344 return resultobj;
28345 fail:
28346 return NULL;
28347 }
28348
28349
28350 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj;
28352 wxWindow *arg1 = (wxWindow *) 0 ;
28353 wxString *arg2 = 0 ;
28354 wxWindow *result;
28355 bool temp2 = false ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self",(char *) "name", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 {
28366 arg2 = wxString_in_helper(obj1);
28367 if (arg2 == NULL) SWIG_fail;
28368 temp2 = true;
28369 }
28370 {
28371 PyThreadState* __tstate = wxPyBeginAllowThreads();
28372 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28373
28374 wxPyEndAllowThreads(__tstate);
28375 if (PyErr_Occurred()) SWIG_fail;
28376 }
28377 {
28378 resultobj = wxPyMake_wxObject(result, 0);
28379 }
28380 {
28381 if (temp2)
28382 delete arg2;
28383 }
28384 return resultobj;
28385 fail:
28386 {
28387 if (temp2)
28388 delete arg2;
28389 }
28390 return NULL;
28391 }
28392
28393
28394 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28395 PyObject *resultobj;
28396 wxWindow *arg1 = (wxWindow *) 0 ;
28397 wxEvtHandler *result;
28398 PyObject * obj0 = 0 ;
28399 char *kwnames[] = {
28400 (char *) "self", NULL
28401 };
28402
28403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28405 if (SWIG_arg_fail(1)) SWIG_fail;
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28409
28410 wxPyEndAllowThreads(__tstate);
28411 if (PyErr_Occurred()) SWIG_fail;
28412 }
28413 {
28414 resultobj = wxPyMake_wxObject(result, 0);
28415 }
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj;
28424 wxWindow *arg1 = (wxWindow *) 0 ;
28425 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28426 PyObject * obj0 = 0 ;
28427 PyObject * obj1 = 0 ;
28428 char *kwnames[] = {
28429 (char *) "self",(char *) "handler", NULL
28430 };
28431
28432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28434 if (SWIG_arg_fail(1)) SWIG_fail;
28435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28436 if (SWIG_arg_fail(2)) SWIG_fail;
28437 {
28438 PyThreadState* __tstate = wxPyBeginAllowThreads();
28439 (arg1)->SetEventHandler(arg2);
28440
28441 wxPyEndAllowThreads(__tstate);
28442 if (PyErr_Occurred()) SWIG_fail;
28443 }
28444 Py_INCREF(Py_None); resultobj = Py_None;
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj;
28453 wxWindow *arg1 = (wxWindow *) 0 ;
28454 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28455 PyObject * obj0 = 0 ;
28456 PyObject * obj1 = 0 ;
28457 char *kwnames[] = {
28458 (char *) "self",(char *) "handler", NULL
28459 };
28460
28461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28463 if (SWIG_arg_fail(1)) SWIG_fail;
28464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28465 if (SWIG_arg_fail(2)) SWIG_fail;
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 (arg1)->PushEventHandler(arg2);
28469
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 Py_INCREF(Py_None); resultobj = Py_None;
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxWindow *arg1 = (wxWindow *) 0 ;
28483 bool arg2 = (bool) false ;
28484 wxEvtHandler *result;
28485 PyObject * obj0 = 0 ;
28486 PyObject * obj1 = 0 ;
28487 char *kwnames[] = {
28488 (char *) "self",(char *) "deleteHandler", NULL
28489 };
28490
28491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(1)) SWIG_fail;
28494 if (obj1) {
28495 {
28496 arg2 = (bool)(SWIG_As_bool(obj1));
28497 if (SWIG_arg_fail(2)) SWIG_fail;
28498 }
28499 }
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28503
28504 wxPyEndAllowThreads(__tstate);
28505 if (PyErr_Occurred()) SWIG_fail;
28506 }
28507 {
28508 resultobj = wxPyMake_wxObject(result, 0);
28509 }
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28517 PyObject *resultobj;
28518 wxWindow *arg1 = (wxWindow *) 0 ;
28519 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28520 bool result;
28521 PyObject * obj0 = 0 ;
28522 PyObject * obj1 = 0 ;
28523 char *kwnames[] = {
28524 (char *) "self",(char *) "handler", NULL
28525 };
28526
28527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28529 if (SWIG_arg_fail(1)) SWIG_fail;
28530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28531 if (SWIG_arg_fail(2)) SWIG_fail;
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (bool)(arg1)->RemoveEventHandler(arg2);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 {
28540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28541 }
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28549 PyObject *resultobj;
28550 wxWindow *arg1 = (wxWindow *) 0 ;
28551 wxValidator *arg2 = 0 ;
28552 PyObject * obj0 = 0 ;
28553 PyObject * obj1 = 0 ;
28554 char *kwnames[] = {
28555 (char *) "self",(char *) "validator", NULL
28556 };
28557
28558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28563 if (SWIG_arg_fail(2)) SWIG_fail;
28564 if (arg2 == NULL) {
28565 SWIG_null_ref("wxValidator");
28566 }
28567 if (SWIG_arg_fail(2)) SWIG_fail;
28568 }
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 (arg1)->SetValidator((wxValidator const &)*arg2);
28572
28573 wxPyEndAllowThreads(__tstate);
28574 if (PyErr_Occurred()) SWIG_fail;
28575 }
28576 Py_INCREF(Py_None); resultobj = Py_None;
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj;
28585 wxWindow *arg1 = (wxWindow *) 0 ;
28586 wxValidator *result;
28587 PyObject * obj0 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "self", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 result = (wxValidator *)(arg1)->GetValidator();
28598
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 {
28603 resultobj = wxPyMake_wxObject(result, 0);
28604 }
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28612 PyObject *resultobj;
28613 wxWindow *arg1 = (wxWindow *) 0 ;
28614 bool result;
28615 PyObject * obj0 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (bool)(arg1)->Validate();
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 bool result;
28643 PyObject * obj0 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (bool)(arg1)->TransferDataToWindow();
28654
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 {
28659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28660 }
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28668 PyObject *resultobj;
28669 wxWindow *arg1 = (wxWindow *) 0 ;
28670 bool result;
28671 PyObject * obj0 = 0 ;
28672 char *kwnames[] = {
28673 (char *) "self", NULL
28674 };
28675
28676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28678 if (SWIG_arg_fail(1)) SWIG_fail;
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (bool)(arg1)->TransferDataFromWindow();
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 {
28687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28688 }
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj;
28697 wxWindow *arg1 = (wxWindow *) 0 ;
28698 PyObject * obj0 = 0 ;
28699 char *kwnames[] = {
28700 (char *) "self", NULL
28701 };
28702
28703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28705 if (SWIG_arg_fail(1)) SWIG_fail;
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 (arg1)->InitDialog();
28709
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 Py_INCREF(Py_None); resultobj = Py_None;
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28721 PyObject *resultobj;
28722 wxWindow *arg1 = (wxWindow *) 0 ;
28723 wxAcceleratorTable *arg2 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 PyObject * obj1 = 0 ;
28726 char *kwnames[] = {
28727 (char *) "self",(char *) "accel", NULL
28728 };
28729
28730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28732 if (SWIG_arg_fail(1)) SWIG_fail;
28733 {
28734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28735 if (SWIG_arg_fail(2)) SWIG_fail;
28736 if (arg2 == NULL) {
28737 SWIG_null_ref("wxAcceleratorTable");
28738 }
28739 if (SWIG_arg_fail(2)) SWIG_fail;
28740 }
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28744
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 Py_INCREF(Py_None); resultobj = Py_None;
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28756 PyObject *resultobj;
28757 wxWindow *arg1 = (wxWindow *) 0 ;
28758 wxAcceleratorTable *result;
28759 PyObject * obj0 = 0 ;
28760 char *kwnames[] = {
28761 (char *) "self", NULL
28762 };
28763
28764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28766 if (SWIG_arg_fail(1)) SWIG_fail;
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28770
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28782 PyObject *resultobj;
28783 wxWindow *arg1 = (wxWindow *) 0 ;
28784 int arg2 ;
28785 int arg3 ;
28786 int arg4 ;
28787 bool result;
28788 PyObject * obj0 = 0 ;
28789 PyObject * obj1 = 0 ;
28790 PyObject * obj2 = 0 ;
28791 PyObject * obj3 = 0 ;
28792 char *kwnames[] = {
28793 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28794 };
28795
28796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28798 if (SWIG_arg_fail(1)) SWIG_fail;
28799 {
28800 arg2 = (int)(SWIG_As_int(obj1));
28801 if (SWIG_arg_fail(2)) SWIG_fail;
28802 }
28803 {
28804 arg3 = (int)(SWIG_As_int(obj2));
28805 if (SWIG_arg_fail(3)) SWIG_fail;
28806 }
28807 {
28808 arg4 = (int)(SWIG_As_int(obj3));
28809 if (SWIG_arg_fail(4)) SWIG_fail;
28810 }
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28814
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 {
28819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28820 }
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj;
28829 wxWindow *arg1 = (wxWindow *) 0 ;
28830 int arg2 ;
28831 bool result;
28832 PyObject * obj0 = 0 ;
28833 PyObject * obj1 = 0 ;
28834 char *kwnames[] = {
28835 (char *) "self",(char *) "hotkeyId", NULL
28836 };
28837
28838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28840 if (SWIG_arg_fail(1)) SWIG_fail;
28841 {
28842 arg2 = (int)(SWIG_As_int(obj1));
28843 if (SWIG_arg_fail(2)) SWIG_fail;
28844 }
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28848
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 {
28853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28854 }
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj;
28863 wxWindow *arg1 = (wxWindow *) 0 ;
28864 wxPoint *arg2 = 0 ;
28865 wxPoint result;
28866 wxPoint temp2 ;
28867 PyObject * obj0 = 0 ;
28868 PyObject * obj1 = 0 ;
28869 char *kwnames[] = {
28870 (char *) "self",(char *) "pt", NULL
28871 };
28872
28873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28875 if (SWIG_arg_fail(1)) SWIG_fail;
28876 {
28877 arg2 = &temp2;
28878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28879 }
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 {
28888 wxPoint * resultptr;
28889 resultptr = new wxPoint((wxPoint &)(result));
28890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28891 }
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj;
28900 wxWindow *arg1 = (wxWindow *) 0 ;
28901 wxSize *arg2 = 0 ;
28902 wxSize result;
28903 wxSize temp2 ;
28904 PyObject * obj0 = 0 ;
28905 PyObject * obj1 = 0 ;
28906 char *kwnames[] = {
28907 (char *) "self",(char *) "sz", NULL
28908 };
28909
28910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28912 if (SWIG_arg_fail(1)) SWIG_fail;
28913 {
28914 arg2 = &temp2;
28915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 {
28925 wxSize * resultptr;
28926 resultptr = new wxSize((wxSize &)(result));
28927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28928 }
28929 return resultobj;
28930 fail:
28931 return NULL;
28932 }
28933
28934
28935 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28936 PyObject *resultobj;
28937 wxWindow *arg1 = (wxWindow *) 0 ;
28938 wxPoint *arg2 = 0 ;
28939 wxPoint result;
28940 wxPoint temp2 ;
28941 PyObject * obj0 = 0 ;
28942 PyObject * obj1 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self",(char *) "pt", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 {
28951 arg2 = &temp2;
28952 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28953 }
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28957
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 {
28962 wxPoint * resultptr;
28963 resultptr = new wxPoint((wxPoint &)(result));
28964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28965 }
28966 return resultobj;
28967 fail:
28968 return NULL;
28969 }
28970
28971
28972 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28973 PyObject *resultobj;
28974 wxWindow *arg1 = (wxWindow *) 0 ;
28975 wxSize *arg2 = 0 ;
28976 wxSize result;
28977 wxSize temp2 ;
28978 PyObject * obj0 = 0 ;
28979 PyObject * obj1 = 0 ;
28980 char *kwnames[] = {
28981 (char *) "self",(char *) "sz", NULL
28982 };
28983
28984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28986 if (SWIG_arg_fail(1)) SWIG_fail;
28987 {
28988 arg2 = &temp2;
28989 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28990 }
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 {
28999 wxSize * resultptr;
29000 resultptr = new wxSize((wxSize &)(result));
29001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29002 }
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29010 PyObject *resultobj;
29011 wxWindow *arg1 = (wxWindow *) 0 ;
29012 wxPoint *arg2 = 0 ;
29013 wxPoint result;
29014 wxPoint temp2 ;
29015 PyObject * obj0 = 0 ;
29016 PyObject * obj1 = 0 ;
29017 char *kwnames[] = {
29018 (char *) "self",(char *) "pt", NULL
29019 };
29020
29021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29023 if (SWIG_arg_fail(1)) SWIG_fail;
29024 {
29025 arg2 = &temp2;
29026 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29027 }
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29031
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 {
29036 wxPoint * resultptr;
29037 resultptr = new wxPoint((wxPoint &)(result));
29038 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29039 }
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj;
29048 wxWindow *arg1 = (wxWindow *) 0 ;
29049 wxSize *arg2 = 0 ;
29050 wxSize result;
29051 wxSize temp2 ;
29052 PyObject * obj0 = 0 ;
29053 PyObject * obj1 = 0 ;
29054 char *kwnames[] = {
29055 (char *) "self",(char *) "sz", NULL
29056 };
29057
29058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29060 if (SWIG_arg_fail(1)) SWIG_fail;
29061 {
29062 arg2 = &temp2;
29063 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29064 }
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 {
29073 wxSize * resultptr;
29074 resultptr = new wxSize((wxSize &)(result));
29075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29076 }
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29084 PyObject *resultobj;
29085 wxWindow *arg1 = (wxWindow *) 0 ;
29086 int arg2 ;
29087 int arg3 ;
29088 PyObject * obj0 = 0 ;
29089 PyObject * obj1 = 0 ;
29090 PyObject * obj2 = 0 ;
29091 char *kwnames[] = {
29092 (char *) "self",(char *) "x",(char *) "y", NULL
29093 };
29094
29095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29097 if (SWIG_arg_fail(1)) SWIG_fail;
29098 {
29099 arg2 = (int)(SWIG_As_int(obj1));
29100 if (SWIG_arg_fail(2)) SWIG_fail;
29101 }
29102 {
29103 arg3 = (int)(SWIG_As_int(obj2));
29104 if (SWIG_arg_fail(3)) SWIG_fail;
29105 }
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 (arg1)->WarpPointer(arg2,arg3);
29109
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 Py_INCREF(Py_None); resultobj = Py_None;
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj;
29122 wxWindow *arg1 = (wxWindow *) 0 ;
29123 PyObject * obj0 = 0 ;
29124 char *kwnames[] = {
29125 (char *) "self", NULL
29126 };
29127
29128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29130 if (SWIG_arg_fail(1)) SWIG_fail;
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 (arg1)->CaptureMouse();
29134
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 Py_INCREF(Py_None); resultobj = Py_None;
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxWindow *arg1 = (wxWindow *) 0 ;
29148 PyObject * obj0 = 0 ;
29149 char *kwnames[] = {
29150 (char *) "self", NULL
29151 };
29152
29153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29155 if (SWIG_arg_fail(1)) SWIG_fail;
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 (arg1)->ReleaseMouse();
29159
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 Py_INCREF(Py_None); resultobj = Py_None;
29164 return resultobj;
29165 fail:
29166 return NULL;
29167 }
29168
29169
29170 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29171 PyObject *resultobj;
29172 wxWindow *result;
29173 char *kwnames[] = {
29174 NULL
29175 };
29176
29177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29178 {
29179 if (!wxPyCheckForApp()) SWIG_fail;
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 result = (wxWindow *)wxWindow::GetCapture();
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 {
29187 resultobj = wxPyMake_wxObject(result, 0);
29188 }
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj;
29197 wxWindow *arg1 = (wxWindow *) 0 ;
29198 bool result;
29199 PyObject * obj0 = 0 ;
29200 char *kwnames[] = {
29201 (char *) "self", NULL
29202 };
29203
29204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29206 if (SWIG_arg_fail(1)) SWIG_fail;
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 result = (bool)((wxWindow const *)arg1)->HasCapture();
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 {
29215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29216 }
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj;
29225 wxWindow *arg1 = (wxWindow *) 0 ;
29226 bool arg2 = (bool) true ;
29227 wxRect *arg3 = (wxRect *) NULL ;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 PyObject * obj2 = 0 ;
29231 char *kwnames[] = {
29232 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29233 };
29234
29235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29237 if (SWIG_arg_fail(1)) SWIG_fail;
29238 if (obj1) {
29239 {
29240 arg2 = (bool)(SWIG_As_bool(obj1));
29241 if (SWIG_arg_fail(2)) SWIG_fail;
29242 }
29243 }
29244 if (obj2) {
29245 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(3)) SWIG_fail;
29247 }
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29251
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 Py_INCREF(Py_None); resultobj = Py_None;
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29263 PyObject *resultobj;
29264 wxWindow *arg1 = (wxWindow *) 0 ;
29265 wxRect *arg2 = 0 ;
29266 bool arg3 = (bool) true ;
29267 wxRect temp2 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 PyObject * obj2 = 0 ;
29271 char *kwnames[] = {
29272 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29273 };
29274
29275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29277 if (SWIG_arg_fail(1)) SWIG_fail;
29278 {
29279 arg2 = &temp2;
29280 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29281 }
29282 if (obj2) {
29283 {
29284 arg3 = (bool)(SWIG_As_bool(obj2));
29285 if (SWIG_arg_fail(3)) SWIG_fail;
29286 }
29287 }
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29291
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 Py_INCREF(Py_None); resultobj = Py_None;
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxWindow *arg1 = (wxWindow *) 0 ;
29305 PyObject * obj0 = 0 ;
29306 char *kwnames[] = {
29307 (char *) "self", NULL
29308 };
29309
29310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(1)) SWIG_fail;
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 (arg1)->Update();
29316
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 Py_INCREF(Py_None); resultobj = Py_None;
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj;
29329 wxWindow *arg1 = (wxWindow *) 0 ;
29330 PyObject * obj0 = 0 ;
29331 char *kwnames[] = {
29332 (char *) "self", NULL
29333 };
29334
29335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29337 if (SWIG_arg_fail(1)) SWIG_fail;
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 (arg1)->ClearBackground();
29341
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 Py_INCREF(Py_None); resultobj = Py_None;
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj;
29354 wxWindow *arg1 = (wxWindow *) 0 ;
29355 PyObject * obj0 = 0 ;
29356 char *kwnames[] = {
29357 (char *) "self", NULL
29358 };
29359
29360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29362 if (SWIG_arg_fail(1)) SWIG_fail;
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 (arg1)->Freeze();
29366
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 Py_INCREF(Py_None); resultobj = Py_None;
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj;
29379 wxWindow *arg1 = (wxWindow *) 0 ;
29380 PyObject * obj0 = 0 ;
29381 char *kwnames[] = {
29382 (char *) "self", NULL
29383 };
29384
29385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29387 if (SWIG_arg_fail(1)) SWIG_fail;
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 (arg1)->Thaw();
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 Py_INCREF(Py_None); resultobj = Py_None;
29396 return resultobj;
29397 fail:
29398 return NULL;
29399 }
29400
29401
29402 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29403 PyObject *resultobj;
29404 wxWindow *arg1 = (wxWindow *) 0 ;
29405 wxDC *arg2 = 0 ;
29406 PyObject * obj0 = 0 ;
29407 PyObject * obj1 = 0 ;
29408 char *kwnames[] = {
29409 (char *) "self",(char *) "dc", NULL
29410 };
29411
29412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29414 if (SWIG_arg_fail(1)) SWIG_fail;
29415 {
29416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(2)) SWIG_fail;
29418 if (arg2 == NULL) {
29419 SWIG_null_ref("wxDC");
29420 }
29421 if (SWIG_arg_fail(2)) SWIG_fail;
29422 }
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 (arg1)->PrepareDC(*arg2);
29426
29427 wxPyEndAllowThreads(__tstate);
29428 if (PyErr_Occurred()) SWIG_fail;
29429 }
29430 Py_INCREF(Py_None); resultobj = Py_None;
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29438 PyObject *resultobj;
29439 wxWindow *arg1 = (wxWindow *) 0 ;
29440 wxRegion *result;
29441 PyObject * obj0 = 0 ;
29442 char *kwnames[] = {
29443 (char *) "self", NULL
29444 };
29445
29446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29448 if (SWIG_arg_fail(1)) SWIG_fail;
29449 {
29450 PyThreadState* __tstate = wxPyBeginAllowThreads();
29451 {
29452 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29453 result = (wxRegion *) &_result_ref;
29454 }
29455
29456 wxPyEndAllowThreads(__tstate);
29457 if (PyErr_Occurred()) SWIG_fail;
29458 }
29459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29460 return resultobj;
29461 fail:
29462 return NULL;
29463 }
29464
29465
29466 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj;
29468 wxWindow *arg1 = (wxWindow *) 0 ;
29469 wxRect result;
29470 PyObject * obj0 = 0 ;
29471 char *kwnames[] = {
29472 (char *) "self", NULL
29473 };
29474
29475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29477 if (SWIG_arg_fail(1)) SWIG_fail;
29478 {
29479 PyThreadState* __tstate = wxPyBeginAllowThreads();
29480 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29481
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 {
29486 wxRect * resultptr;
29487 resultptr = new wxRect((wxRect &)(result));
29488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29489 }
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29497 PyObject *resultobj;
29498 wxWindow *arg1 = (wxWindow *) 0 ;
29499 int arg2 ;
29500 int arg3 ;
29501 int arg4 = (int) 1 ;
29502 int arg5 = (int) 1 ;
29503 bool result;
29504 PyObject * obj0 = 0 ;
29505 PyObject * obj1 = 0 ;
29506 PyObject * obj2 = 0 ;
29507 PyObject * obj3 = 0 ;
29508 PyObject * obj4 = 0 ;
29509 char *kwnames[] = {
29510 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29511 };
29512
29513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29515 if (SWIG_arg_fail(1)) SWIG_fail;
29516 {
29517 arg2 = (int)(SWIG_As_int(obj1));
29518 if (SWIG_arg_fail(2)) SWIG_fail;
29519 }
29520 {
29521 arg3 = (int)(SWIG_As_int(obj2));
29522 if (SWIG_arg_fail(3)) SWIG_fail;
29523 }
29524 if (obj3) {
29525 {
29526 arg4 = (int)(SWIG_As_int(obj3));
29527 if (SWIG_arg_fail(4)) SWIG_fail;
29528 }
29529 }
29530 if (obj4) {
29531 {
29532 arg5 = (int)(SWIG_As_int(obj4));
29533 if (SWIG_arg_fail(5)) SWIG_fail;
29534 }
29535 }
29536 {
29537 PyThreadState* __tstate = wxPyBeginAllowThreads();
29538 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29539
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 {
29544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29545 }
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29553 PyObject *resultobj;
29554 wxWindow *arg1 = (wxWindow *) 0 ;
29555 wxPoint *arg2 = 0 ;
29556 bool result;
29557 wxPoint temp2 ;
29558 PyObject * obj0 = 0 ;
29559 PyObject * obj1 = 0 ;
29560 char *kwnames[] = {
29561 (char *) "self",(char *) "pt", NULL
29562 };
29563
29564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29566 if (SWIG_arg_fail(1)) SWIG_fail;
29567 {
29568 arg2 = &temp2;
29569 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29570 }
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 {
29579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29580 }
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29588 PyObject *resultobj;
29589 wxWindow *arg1 = (wxWindow *) 0 ;
29590 wxRect *arg2 = 0 ;
29591 bool result;
29592 wxRect temp2 ;
29593 PyObject * obj0 = 0 ;
29594 PyObject * obj1 = 0 ;
29595 char *kwnames[] = {
29596 (char *) "self",(char *) "rect", NULL
29597 };
29598
29599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29601 if (SWIG_arg_fail(1)) SWIG_fail;
29602 {
29603 arg2 = &temp2;
29604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29605 }
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29609
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 {
29614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29615 }
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj;
29624 wxWindow *arg1 = (wxWindow *) 0 ;
29625 wxVisualAttributes result;
29626 PyObject * obj0 = 0 ;
29627 char *kwnames[] = {
29628 (char *) "self", NULL
29629 };
29630
29631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29633 if (SWIG_arg_fail(1)) SWIG_fail;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 {
29642 wxVisualAttributes * resultptr;
29643 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29645 }
29646 return resultobj;
29647 fail:
29648 return NULL;
29649 }
29650
29651
29652 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29653 PyObject *resultobj;
29654 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29655 wxVisualAttributes result;
29656 PyObject * obj0 = 0 ;
29657 char *kwnames[] = {
29658 (char *) "variant", NULL
29659 };
29660
29661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29662 if (obj0) {
29663 {
29664 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29665 if (SWIG_arg_fail(1)) SWIG_fail;
29666 }
29667 }
29668 {
29669 if (!wxPyCheckForApp()) SWIG_fail;
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29672
29673 wxPyEndAllowThreads(__tstate);
29674 if (PyErr_Occurred()) SWIG_fail;
29675 }
29676 {
29677 wxVisualAttributes * resultptr;
29678 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29680 }
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj;
29689 wxWindow *arg1 = (wxWindow *) 0 ;
29690 wxColour *arg2 = 0 ;
29691 bool result;
29692 wxColour temp2 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 char *kwnames[] = {
29696 (char *) "self",(char *) "colour", NULL
29697 };
29698
29699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29701 if (SWIG_arg_fail(1)) SWIG_fail;
29702 {
29703 arg2 = &temp2;
29704 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29705 }
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29709
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 {
29714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29715 }
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj;
29724 wxWindow *arg1 = (wxWindow *) 0 ;
29725 wxColour *arg2 = 0 ;
29726 wxColour temp2 ;
29727 PyObject * obj0 = 0 ;
29728 PyObject * obj1 = 0 ;
29729 char *kwnames[] = {
29730 (char *) "self",(char *) "colour", NULL
29731 };
29732
29733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29735 if (SWIG_arg_fail(1)) SWIG_fail;
29736 {
29737 arg2 = &temp2;
29738 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29739 }
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29743
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 Py_INCREF(Py_None); resultobj = Py_None;
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj;
29756 wxWindow *arg1 = (wxWindow *) 0 ;
29757 wxColour *arg2 = 0 ;
29758 bool result;
29759 wxColour temp2 ;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char *kwnames[] = {
29763 (char *) "self",(char *) "colour", NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29768 if (SWIG_arg_fail(1)) SWIG_fail;
29769 {
29770 arg2 = &temp2;
29771 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29772 }
29773 {
29774 PyThreadState* __tstate = wxPyBeginAllowThreads();
29775 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29776
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 {
29781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29782 }
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29790 PyObject *resultobj;
29791 wxWindow *arg1 = (wxWindow *) 0 ;
29792 wxColour *arg2 = 0 ;
29793 wxColour temp2 ;
29794 PyObject * obj0 = 0 ;
29795 PyObject * obj1 = 0 ;
29796 char *kwnames[] = {
29797 (char *) "self",(char *) "colour", NULL
29798 };
29799
29800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29802 if (SWIG_arg_fail(1)) SWIG_fail;
29803 {
29804 arg2 = &temp2;
29805 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29806 }
29807 {
29808 PyThreadState* __tstate = wxPyBeginAllowThreads();
29809 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29810
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 Py_INCREF(Py_None); resultobj = Py_None;
29815 return resultobj;
29816 fail:
29817 return NULL;
29818 }
29819
29820
29821 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29822 PyObject *resultobj;
29823 wxWindow *arg1 = (wxWindow *) 0 ;
29824 wxColour result;
29825 PyObject * obj0 = 0 ;
29826 char *kwnames[] = {
29827 (char *) "self", NULL
29828 };
29829
29830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29832 if (SWIG_arg_fail(1)) SWIG_fail;
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29836
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 wxColour * resultptr;
29842 resultptr = new wxColour((wxColour &)(result));
29843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29844 }
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29852 PyObject *resultobj;
29853 wxWindow *arg1 = (wxWindow *) 0 ;
29854 wxColour result;
29855 PyObject * obj0 = 0 ;
29856 char *kwnames[] = {
29857 (char *) "self", NULL
29858 };
29859
29860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29862 if (SWIG_arg_fail(1)) SWIG_fail;
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 result = ((wxWindow const *)arg1)->GetForegroundColour();
29866
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 {
29871 wxColour * resultptr;
29872 resultptr = new wxColour((wxColour &)(result));
29873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29874 }
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 bool result;
29885 PyObject * obj0 = 0 ;
29886 char *kwnames[] = {
29887 (char *) "self", NULL
29888 };
29889
29890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29892 if (SWIG_arg_fail(1)) SWIG_fail;
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
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_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 bool result;
29913 PyObject * obj0 = 0 ;
29914 char *kwnames[] = {
29915 (char *) "self", NULL
29916 };
29917
29918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",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 = (bool)((wxWindow const *)arg1)->UseBgCol();
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 {
29929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29930 }
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 wxBackgroundStyle arg2 ;
29941 bool result;
29942 PyObject * obj0 = 0 ;
29943 PyObject * obj1 = 0 ;
29944 char *kwnames[] = {
29945 (char *) "self",(char *) "style", NULL
29946 };
29947
29948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29950 if (SWIG_arg_fail(1)) SWIG_fail;
29951 {
29952 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29953 if (SWIG_arg_fail(2)) SWIG_fail;
29954 }
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29958
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29964 }
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj;
29973 wxWindow *arg1 = (wxWindow *) 0 ;
29974 wxBackgroundStyle result;
29975 PyObject * obj0 = 0 ;
29976 char *kwnames[] = {
29977 (char *) "self", NULL
29978 };
29979
29980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29982 if (SWIG_arg_fail(1)) SWIG_fail;
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29986
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_From_int((result));
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj;
29999 wxWindow *arg1 = (wxWindow *) 0 ;
30000 bool result;
30001 PyObject * obj0 = 0 ;
30002 char *kwnames[] = {
30003 (char *) "self", NULL
30004 };
30005
30006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30008 if (SWIG_arg_fail(1)) SWIG_fail;
30009 {
30010 PyThreadState* __tstate = wxPyBeginAllowThreads();
30011 result = (bool)(arg1)->HasTransparentBackground();
30012
30013 wxPyEndAllowThreads(__tstate);
30014 if (PyErr_Occurred()) SWIG_fail;
30015 }
30016 {
30017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30018 }
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30026 PyObject *resultobj;
30027 wxWindow *arg1 = (wxWindow *) 0 ;
30028 wxCursor *arg2 = 0 ;
30029 bool result;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char *kwnames[] = {
30033 (char *) "self",(char *) "cursor", NULL
30034 };
30035
30036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30038 if (SWIG_arg_fail(1)) SWIG_fail;
30039 {
30040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30041 if (SWIG_arg_fail(2)) SWIG_fail;
30042 if (arg2 == NULL) {
30043 SWIG_null_ref("wxCursor");
30044 }
30045 if (SWIG_arg_fail(2)) SWIG_fail;
30046 }
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30050
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 {
30055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30056 }
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj;
30065 wxWindow *arg1 = (wxWindow *) 0 ;
30066 wxCursor result;
30067 PyObject * obj0 = 0 ;
30068 char *kwnames[] = {
30069 (char *) "self", NULL
30070 };
30071
30072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30074 if (SWIG_arg_fail(1)) SWIG_fail;
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = (arg1)->GetCursor();
30078
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 {
30083 wxCursor * resultptr;
30084 resultptr = new wxCursor((wxCursor &)(result));
30085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30086 }
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30094 PyObject *resultobj;
30095 wxWindow *arg1 = (wxWindow *) 0 ;
30096 wxFont *arg2 = 0 ;
30097 bool result;
30098 PyObject * obj0 = 0 ;
30099 PyObject * obj1 = 0 ;
30100 char *kwnames[] = {
30101 (char *) "self",(char *) "font", NULL
30102 };
30103
30104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30106 if (SWIG_arg_fail(1)) SWIG_fail;
30107 {
30108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30109 if (SWIG_arg_fail(2)) SWIG_fail;
30110 if (arg2 == NULL) {
30111 SWIG_null_ref("wxFont");
30112 }
30113 if (SWIG_arg_fail(2)) SWIG_fail;
30114 }
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30118
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 {
30123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj;
30133 wxWindow *arg1 = (wxWindow *) 0 ;
30134 wxFont *arg2 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 char *kwnames[] = {
30138 (char *) "self",(char *) "font", NULL
30139 };
30140
30141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30143 if (SWIG_arg_fail(1)) SWIG_fail;
30144 {
30145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(2)) SWIG_fail;
30147 if (arg2 == NULL) {
30148 SWIG_null_ref("wxFont");
30149 }
30150 if (SWIG_arg_fail(2)) SWIG_fail;
30151 }
30152 {
30153 PyThreadState* __tstate = wxPyBeginAllowThreads();
30154 (arg1)->SetOwnFont((wxFont const &)*arg2);
30155
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 Py_INCREF(Py_None); resultobj = Py_None;
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30167 PyObject *resultobj;
30168 wxWindow *arg1 = (wxWindow *) 0 ;
30169 wxFont result;
30170 PyObject * obj0 = 0 ;
30171 char *kwnames[] = {
30172 (char *) "self", NULL
30173 };
30174
30175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30177 if (SWIG_arg_fail(1)) SWIG_fail;
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 result = (arg1)->GetFont();
30181
30182 wxPyEndAllowThreads(__tstate);
30183 if (PyErr_Occurred()) SWIG_fail;
30184 }
30185 {
30186 wxFont * resultptr;
30187 resultptr = new wxFont((wxFont &)(result));
30188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30189 }
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj;
30198 wxWindow *arg1 = (wxWindow *) 0 ;
30199 wxCaret *arg2 = (wxCaret *) 0 ;
30200 PyObject * obj0 = 0 ;
30201 PyObject * obj1 = 0 ;
30202 char *kwnames[] = {
30203 (char *) "self",(char *) "caret", NULL
30204 };
30205
30206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30208 if (SWIG_arg_fail(1)) SWIG_fail;
30209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(2)) SWIG_fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 (arg1)->SetCaret(arg2);
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 Py_INCREF(Py_None); resultobj = Py_None;
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxWindow *arg1 = (wxWindow *) 0 ;
30228 wxCaret *result;
30229 PyObject * obj0 = 0 ;
30230 char *kwnames[] = {
30231 (char *) "self", NULL
30232 };
30233
30234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(1)) SWIG_fail;
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30240
30241 wxPyEndAllowThreads(__tstate);
30242 if (PyErr_Occurred()) SWIG_fail;
30243 }
30244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj;
30253 wxWindow *arg1 = (wxWindow *) 0 ;
30254 int result;
30255 PyObject * obj0 = 0 ;
30256 char *kwnames[] = {
30257 (char *) "self", NULL
30258 };
30259
30260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30262 if (SWIG_arg_fail(1)) SWIG_fail;
30263 {
30264 PyThreadState* __tstate = wxPyBeginAllowThreads();
30265 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30266
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 {
30271 resultobj = SWIG_From_int((int)(result));
30272 }
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj;
30281 wxWindow *arg1 = (wxWindow *) 0 ;
30282 int result;
30283 PyObject * obj0 = 0 ;
30284 char *kwnames[] = {
30285 (char *) "self", NULL
30286 };
30287
30288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30290 if (SWIG_arg_fail(1)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 {
30299 resultobj = SWIG_From_int((int)(result));
30300 }
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 wxString *arg2 = 0 ;
30311 int *arg3 = (int *) 0 ;
30312 int *arg4 = (int *) 0 ;
30313 bool temp2 = false ;
30314 int temp3 ;
30315 int res3 = 0 ;
30316 int temp4 ;
30317 int res4 = 0 ;
30318 PyObject * obj0 = 0 ;
30319 PyObject * obj1 = 0 ;
30320 char *kwnames[] = {
30321 (char *) "self",(char *) "string", NULL
30322 };
30323
30324 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30325 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 arg2 = wxString_in_helper(obj1);
30331 if (arg2 == NULL) SWIG_fail;
30332 temp2 = true;
30333 }
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30337
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 Py_INCREF(Py_None); resultobj = Py_None;
30342 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30343 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30344 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30345 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30346 {
30347 if (temp2)
30348 delete arg2;
30349 }
30350 return resultobj;
30351 fail:
30352 {
30353 if (temp2)
30354 delete arg2;
30355 }
30356 return NULL;
30357 }
30358
30359
30360 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30361 PyObject *resultobj;
30362 wxWindow *arg1 = (wxWindow *) 0 ;
30363 wxString *arg2 = 0 ;
30364 int *arg3 = (int *) 0 ;
30365 int *arg4 = (int *) 0 ;
30366 int *arg5 = (int *) 0 ;
30367 int *arg6 = (int *) 0 ;
30368 wxFont *arg7 = (wxFont *) NULL ;
30369 bool temp2 = false ;
30370 int temp3 ;
30371 int res3 = 0 ;
30372 int temp4 ;
30373 int res4 = 0 ;
30374 int temp5 ;
30375 int res5 = 0 ;
30376 int temp6 ;
30377 int res6 = 0 ;
30378 PyObject * obj0 = 0 ;
30379 PyObject * obj1 = 0 ;
30380 PyObject * obj2 = 0 ;
30381 char *kwnames[] = {
30382 (char *) "self",(char *) "string",(char *) "font", NULL
30383 };
30384
30385 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30386 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30387 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30388 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30391 if (SWIG_arg_fail(1)) SWIG_fail;
30392 {
30393 arg2 = wxString_in_helper(obj1);
30394 if (arg2 == NULL) SWIG_fail;
30395 temp2 = true;
30396 }
30397 if (obj2) {
30398 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30399 if (SWIG_arg_fail(7)) SWIG_fail;
30400 }
30401 {
30402 PyThreadState* __tstate = wxPyBeginAllowThreads();
30403 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30404
30405 wxPyEndAllowThreads(__tstate);
30406 if (PyErr_Occurred()) SWIG_fail;
30407 }
30408 Py_INCREF(Py_None); resultobj = Py_None;
30409 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30410 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30411 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30412 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30413 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30414 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30415 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30416 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30417 {
30418 if (temp2)
30419 delete arg2;
30420 }
30421 return resultobj;
30422 fail:
30423 {
30424 if (temp2)
30425 delete arg2;
30426 }
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxWindow *arg1 = (wxWindow *) 0 ;
30434 int *arg2 = (int *) 0 ;
30435 int *arg3 = (int *) 0 ;
30436 int temp2 ;
30437 int res2 = 0 ;
30438 int temp3 ;
30439 int res3 = 0 ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 PyObject * obj2 = 0 ;
30443 char *kwnames[] = {
30444 (char *) "self",(char *) "x",(char *) "y", NULL
30445 };
30446
30447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30449 if (SWIG_arg_fail(1)) SWIG_fail;
30450 {
30451 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30452 temp2 = SWIG_As_int(obj1);
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 arg2 = &temp2;
30455 res2 = SWIG_NEWOBJ;
30456 }
30457 }
30458 {
30459 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30460 temp3 = SWIG_As_int(obj2);
30461 if (SWIG_arg_fail(3)) SWIG_fail;
30462 arg3 = &temp3;
30463 res3 = SWIG_NEWOBJ;
30464 }
30465 }
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30469
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 Py_INCREF(Py_None); resultobj = Py_None;
30474 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30475 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30476 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30477 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30485 PyObject *resultobj;
30486 wxWindow *arg1 = (wxWindow *) 0 ;
30487 int *arg2 = (int *) 0 ;
30488 int *arg3 = (int *) 0 ;
30489 int temp2 ;
30490 int res2 = 0 ;
30491 int temp3 ;
30492 int res3 = 0 ;
30493 PyObject * obj0 = 0 ;
30494 PyObject * obj1 = 0 ;
30495 PyObject * obj2 = 0 ;
30496 char *kwnames[] = {
30497 (char *) "self",(char *) "x",(char *) "y", NULL
30498 };
30499
30500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30502 if (SWIG_arg_fail(1)) SWIG_fail;
30503 {
30504 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30505 temp2 = SWIG_As_int(obj1);
30506 if (SWIG_arg_fail(2)) SWIG_fail;
30507 arg2 = &temp2;
30508 res2 = SWIG_NEWOBJ;
30509 }
30510 }
30511 {
30512 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30513 temp3 = SWIG_As_int(obj2);
30514 if (SWIG_arg_fail(3)) SWIG_fail;
30515 arg3 = &temp3;
30516 res3 = SWIG_NEWOBJ;
30517 }
30518 }
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30522
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 Py_INCREF(Py_None); resultobj = Py_None;
30527 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30528 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30529 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30530 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30538 PyObject *resultobj;
30539 wxWindow *arg1 = (wxWindow *) 0 ;
30540 wxPoint *arg2 = 0 ;
30541 wxPoint result;
30542 wxPoint temp2 ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 char *kwnames[] = {
30546 (char *) "self",(char *) "pt", NULL
30547 };
30548
30549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30551 if (SWIG_arg_fail(1)) SWIG_fail;
30552 {
30553 arg2 = &temp2;
30554 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30555 }
30556 {
30557 PyThreadState* __tstate = wxPyBeginAllowThreads();
30558 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30559
30560 wxPyEndAllowThreads(__tstate);
30561 if (PyErr_Occurred()) SWIG_fail;
30562 }
30563 {
30564 wxPoint * resultptr;
30565 resultptr = new wxPoint((wxPoint &)(result));
30566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30567 }
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj;
30576 wxWindow *arg1 = (wxWindow *) 0 ;
30577 wxPoint *arg2 = 0 ;
30578 wxPoint result;
30579 wxPoint temp2 ;
30580 PyObject * obj0 = 0 ;
30581 PyObject * obj1 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self",(char *) "pt", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 arg2 = &temp2;
30591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30592 }
30593 {
30594 PyThreadState* __tstate = wxPyBeginAllowThreads();
30595 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30596
30597 wxPyEndAllowThreads(__tstate);
30598 if (PyErr_Occurred()) SWIG_fail;
30599 }
30600 {
30601 wxPoint * resultptr;
30602 resultptr = new wxPoint((wxPoint &)(result));
30603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30604 }
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30612 PyObject *resultobj;
30613 wxWindow *arg1 = (wxWindow *) 0 ;
30614 int arg2 ;
30615 int arg3 ;
30616 wxHitTest result;
30617 PyObject * obj0 = 0 ;
30618 PyObject * obj1 = 0 ;
30619 PyObject * obj2 = 0 ;
30620 char *kwnames[] = {
30621 (char *) "self",(char *) "x",(char *) "y", NULL
30622 };
30623
30624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30626 if (SWIG_arg_fail(1)) SWIG_fail;
30627 {
30628 arg2 = (int)(SWIG_As_int(obj1));
30629 if (SWIG_arg_fail(2)) SWIG_fail;
30630 }
30631 {
30632 arg3 = (int)(SWIG_As_int(obj2));
30633 if (SWIG_arg_fail(3)) SWIG_fail;
30634 }
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
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_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj;
30651 wxWindow *arg1 = (wxWindow *) 0 ;
30652 wxPoint *arg2 = 0 ;
30653 wxHitTest result;
30654 wxPoint temp2 ;
30655 PyObject * obj0 = 0 ;
30656 PyObject * obj1 = 0 ;
30657 char *kwnames[] = {
30658 (char *) "self",(char *) "pt", NULL
30659 };
30660
30661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30663 if (SWIG_arg_fail(1)) SWIG_fail;
30664 {
30665 arg2 = &temp2;
30666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30667 }
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30671
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 resultobj = SWIG_From_int((result));
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30683 PyObject *resultobj;
30684 wxWindow *arg1 = (wxWindow *) 0 ;
30685 long arg2 ;
30686 wxBorder result;
30687 PyObject * obj0 = 0 ;
30688 PyObject * obj1 = 0 ;
30689
30690 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30692 if (SWIG_arg_fail(1)) SWIG_fail;
30693 {
30694 arg2 = (long)(SWIG_As_long(obj1));
30695 if (SWIG_arg_fail(2)) SWIG_fail;
30696 }
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 resultobj = SWIG_From_int((result));
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30712 PyObject *resultobj;
30713 wxWindow *arg1 = (wxWindow *) 0 ;
30714 wxBorder result;
30715 PyObject * obj0 = 0 ;
30716
30717 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30719 if (SWIG_arg_fail(1)) SWIG_fail;
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30723
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_From_int((result));
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30735 int argc;
30736 PyObject *argv[3];
30737 int ii;
30738
30739 argc = PyObject_Length(args);
30740 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30741 argv[ii] = PyTuple_GetItem(args,ii);
30742 }
30743 if (argc == 1) {
30744 int _v;
30745 {
30746 void *ptr;
30747 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30748 _v = 0;
30749 PyErr_Clear();
30750 } else {
30751 _v = 1;
30752 }
30753 }
30754 if (_v) {
30755 return _wrap_Window_GetBorder__SWIG_1(self,args);
30756 }
30757 }
30758 if (argc == 2) {
30759 int _v;
30760 {
30761 void *ptr;
30762 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30763 _v = 0;
30764 PyErr_Clear();
30765 } else {
30766 _v = 1;
30767 }
30768 }
30769 if (_v) {
30770 _v = SWIG_Check_long(argv[1]);
30771 if (_v) {
30772 return _wrap_Window_GetBorder__SWIG_0(self,args);
30773 }
30774 }
30775 }
30776
30777 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30778 return NULL;
30779 }
30780
30781
30782 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30783 PyObject *resultobj;
30784 wxWindow *arg1 = (wxWindow *) 0 ;
30785 long arg2 = (long) wxUPDATE_UI_NONE ;
30786 PyObject * obj0 = 0 ;
30787 PyObject * obj1 = 0 ;
30788 char *kwnames[] = {
30789 (char *) "self",(char *) "flags", NULL
30790 };
30791
30792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30794 if (SWIG_arg_fail(1)) SWIG_fail;
30795 if (obj1) {
30796 {
30797 arg2 = (long)(SWIG_As_long(obj1));
30798 if (SWIG_arg_fail(2)) SWIG_fail;
30799 }
30800 }
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->UpdateWindowUI(arg2);
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 Py_INCREF(Py_None); resultobj = Py_None;
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxMenu *arg2 = (wxMenu *) 0 ;
30819 int arg3 = (int) -1 ;
30820 int arg4 = (int) -1 ;
30821 bool result;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 PyObject * obj2 = 0 ;
30825 PyObject * obj3 = 0 ;
30826 char *kwnames[] = {
30827 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30828 };
30829
30830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30832 if (SWIG_arg_fail(1)) SWIG_fail;
30833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(2)) SWIG_fail;
30835 if (obj2) {
30836 {
30837 arg3 = (int)(SWIG_As_int(obj2));
30838 if (SWIG_arg_fail(3)) SWIG_fail;
30839 }
30840 }
30841 if (obj3) {
30842 {
30843 arg4 = (int)(SWIG_As_int(obj3));
30844 if (SWIG_arg_fail(4)) SWIG_fail;
30845 }
30846 }
30847 {
30848 PyThreadState* __tstate = wxPyBeginAllowThreads();
30849 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30850
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 {
30855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30856 }
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30864 PyObject *resultobj;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 wxMenu *arg2 = (wxMenu *) 0 ;
30867 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30868 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30869 bool result;
30870 wxPoint temp3 ;
30871 PyObject * obj0 = 0 ;
30872 PyObject * obj1 = 0 ;
30873 PyObject * obj2 = 0 ;
30874 char *kwnames[] = {
30875 (char *) "self",(char *) "menu",(char *) "pos", NULL
30876 };
30877
30878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(1)) SWIG_fail;
30881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30882 if (SWIG_arg_fail(2)) SWIG_fail;
30883 if (obj2) {
30884 {
30885 arg3 = &temp3;
30886 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30887 }
30888 }
30889 {
30890 PyThreadState* __tstate = wxPyBeginAllowThreads();
30891 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30892
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 {
30897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30898 }
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 long result;
30909 PyObject * obj0 = 0 ;
30910 char *kwnames[] = {
30911 (char *) "self", NULL
30912 };
30913
30914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30916 if (SWIG_arg_fail(1)) SWIG_fail;
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 result = (long)wxWindow_GetHandle(arg1);
30920
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 {
30925 resultobj = SWIG_From_long((long)(result));
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 long arg2 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char *kwnames[] = {
30940 (char *) "self",(char *) "handle", NULL
30941 };
30942
30943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30945 if (SWIG_arg_fail(1)) SWIG_fail;
30946 {
30947 arg2 = (long)(SWIG_As_long(obj1));
30948 if (SWIG_arg_fail(2)) SWIG_fail;
30949 }
30950 {
30951 PyThreadState* __tstate = wxPyBeginAllowThreads();
30952 wxWindow_AssociateHandle(arg1,arg2);
30953
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 Py_INCREF(Py_None); resultobj = Py_None;
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 PyObject * obj0 = 0 ;
30968 char *kwnames[] = {
30969 (char *) "self", NULL
30970 };
30971
30972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30974 if (SWIG_arg_fail(1)) SWIG_fail;
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 (arg1)->DissociateHandle();
30978
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 Py_INCREF(Py_None); resultobj = Py_None;
30983 return resultobj;
30984 fail:
30985 return NULL;
30986 }
30987
30988
30989 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30990 PyObject *resultobj;
30991 wxWindow *arg1 = (wxWindow *) 0 ;
30992 wxPaintEvent *arg2 = 0 ;
30993 PyObject * obj0 = 0 ;
30994 PyObject * obj1 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self",(char *) "event", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(2)) SWIG_fail;
31005 if (arg2 == NULL) {
31006 SWIG_null_ref("wxPaintEvent");
31007 }
31008 if (SWIG_arg_fail(2)) SWIG_fail;
31009 }
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 (arg1)->OnPaint(*arg2);
31013
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 Py_INCREF(Py_None); resultobj = Py_None;
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxWindow *arg1 = (wxWindow *) 0 ;
31027 int arg2 ;
31028 bool result;
31029 PyObject * obj0 = 0 ;
31030 PyObject * obj1 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self",(char *) "orient", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 arg2 = (int)(SWIG_As_int(obj1));
31040 if (SWIG_arg_fail(2)) SWIG_fail;
31041 }
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31045
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 {
31050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31051 }
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj;
31060 wxWindow *arg1 = (wxWindow *) 0 ;
31061 int arg2 ;
31062 int arg3 ;
31063 int arg4 ;
31064 int arg5 ;
31065 bool arg6 = (bool) true ;
31066 PyObject * obj0 = 0 ;
31067 PyObject * obj1 = 0 ;
31068 PyObject * obj2 = 0 ;
31069 PyObject * obj3 = 0 ;
31070 PyObject * obj4 = 0 ;
31071 PyObject * obj5 = 0 ;
31072 char *kwnames[] = {
31073 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31074 };
31075
31076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31078 if (SWIG_arg_fail(1)) SWIG_fail;
31079 {
31080 arg2 = (int)(SWIG_As_int(obj1));
31081 if (SWIG_arg_fail(2)) SWIG_fail;
31082 }
31083 {
31084 arg3 = (int)(SWIG_As_int(obj2));
31085 if (SWIG_arg_fail(3)) SWIG_fail;
31086 }
31087 {
31088 arg4 = (int)(SWIG_As_int(obj3));
31089 if (SWIG_arg_fail(4)) SWIG_fail;
31090 }
31091 {
31092 arg5 = (int)(SWIG_As_int(obj4));
31093 if (SWIG_arg_fail(5)) SWIG_fail;
31094 }
31095 if (obj5) {
31096 {
31097 arg6 = (bool)(SWIG_As_bool(obj5));
31098 if (SWIG_arg_fail(6)) SWIG_fail;
31099 }
31100 }
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31104
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 Py_INCREF(Py_None); resultobj = Py_None;
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 int arg2 ;
31119 int arg3 ;
31120 bool arg4 = (bool) true ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 PyObject * obj2 = 0 ;
31124 PyObject * obj3 = 0 ;
31125 char *kwnames[] = {
31126 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31127 };
31128
31129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31131 if (SWIG_arg_fail(1)) SWIG_fail;
31132 {
31133 arg2 = (int)(SWIG_As_int(obj1));
31134 if (SWIG_arg_fail(2)) SWIG_fail;
31135 }
31136 {
31137 arg3 = (int)(SWIG_As_int(obj2));
31138 if (SWIG_arg_fail(3)) SWIG_fail;
31139 }
31140 if (obj3) {
31141 {
31142 arg4 = (bool)(SWIG_As_bool(obj3));
31143 if (SWIG_arg_fail(4)) SWIG_fail;
31144 }
31145 }
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 (arg1)->SetScrollPos(arg2,arg3,arg4);
31149
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 Py_INCREF(Py_None); resultobj = Py_None;
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj;
31162 wxWindow *arg1 = (wxWindow *) 0 ;
31163 int arg2 ;
31164 int result;
31165 PyObject * obj0 = 0 ;
31166 PyObject * obj1 = 0 ;
31167 char *kwnames[] = {
31168 (char *) "self",(char *) "orientation", NULL
31169 };
31170
31171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31173 if (SWIG_arg_fail(1)) SWIG_fail;
31174 {
31175 arg2 = (int)(SWIG_As_int(obj1));
31176 if (SWIG_arg_fail(2)) SWIG_fail;
31177 }
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31181
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 {
31186 resultobj = SWIG_From_int((int)(result));
31187 }
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj;
31196 wxWindow *arg1 = (wxWindow *) 0 ;
31197 int arg2 ;
31198 int result;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self",(char *) "orientation", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 arg2 = (int)(SWIG_As_int(obj1));
31210 if (SWIG_arg_fail(2)) SWIG_fail;
31211 }
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31215
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 {
31220 resultobj = SWIG_From_int((int)(result));
31221 }
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj;
31230 wxWindow *arg1 = (wxWindow *) 0 ;
31231 int arg2 ;
31232 int result;
31233 PyObject * obj0 = 0 ;
31234 PyObject * obj1 = 0 ;
31235 char *kwnames[] = {
31236 (char *) "self",(char *) "orientation", NULL
31237 };
31238
31239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31241 if (SWIG_arg_fail(1)) SWIG_fail;
31242 {
31243 arg2 = (int)(SWIG_As_int(obj1));
31244 if (SWIG_arg_fail(2)) SWIG_fail;
31245 }
31246 {
31247 PyThreadState* __tstate = wxPyBeginAllowThreads();
31248 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31249
31250 wxPyEndAllowThreads(__tstate);
31251 if (PyErr_Occurred()) SWIG_fail;
31252 }
31253 {
31254 resultobj = SWIG_From_int((int)(result));
31255 }
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 int arg2 ;
31266 int arg3 ;
31267 wxRect *arg4 = (wxRect *) NULL ;
31268 PyObject * obj0 = 0 ;
31269 PyObject * obj1 = 0 ;
31270 PyObject * obj2 = 0 ;
31271 PyObject * obj3 = 0 ;
31272 char *kwnames[] = {
31273 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31274 };
31275
31276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31278 if (SWIG_arg_fail(1)) SWIG_fail;
31279 {
31280 arg2 = (int)(SWIG_As_int(obj1));
31281 if (SWIG_arg_fail(2)) SWIG_fail;
31282 }
31283 {
31284 arg3 = (int)(SWIG_As_int(obj2));
31285 if (SWIG_arg_fail(3)) SWIG_fail;
31286 }
31287 if (obj3) {
31288 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31289 if (SWIG_arg_fail(4)) SWIG_fail;
31290 }
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 Py_INCREF(Py_None); resultobj = Py_None;
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 int arg2 ;
31309 bool result;
31310 PyObject * obj0 = 0 ;
31311 PyObject * obj1 = 0 ;
31312 char *kwnames[] = {
31313 (char *) "self",(char *) "lines", NULL
31314 };
31315
31316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31318 if (SWIG_arg_fail(1)) SWIG_fail;
31319 {
31320 arg2 = (int)(SWIG_As_int(obj1));
31321 if (SWIG_arg_fail(2)) SWIG_fail;
31322 }
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (bool)(arg1)->ScrollLines(arg2);
31326
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 {
31331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31332 }
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj;
31341 wxWindow *arg1 = (wxWindow *) 0 ;
31342 int arg2 ;
31343 bool result;
31344 PyObject * obj0 = 0 ;
31345 PyObject * obj1 = 0 ;
31346 char *kwnames[] = {
31347 (char *) "self",(char *) "pages", NULL
31348 };
31349
31350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31352 if (SWIG_arg_fail(1)) SWIG_fail;
31353 {
31354 arg2 = (int)(SWIG_As_int(obj1));
31355 if (SWIG_arg_fail(2)) SWIG_fail;
31356 }
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 result = (bool)(arg1)->ScrollPages(arg2);
31360
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 {
31365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31366 }
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj;
31375 wxWindow *arg1 = (wxWindow *) 0 ;
31376 bool result;
31377 PyObject * obj0 = 0 ;
31378 char *kwnames[] = {
31379 (char *) "self", NULL
31380 };
31381
31382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31384 if (SWIG_arg_fail(1)) SWIG_fail;
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 result = (bool)(arg1)->LineUp();
31388
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31394 }
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj;
31403 wxWindow *arg1 = (wxWindow *) 0 ;
31404 bool result;
31405 PyObject * obj0 = 0 ;
31406 char *kwnames[] = {
31407 (char *) "self", NULL
31408 };
31409
31410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31412 if (SWIG_arg_fail(1)) SWIG_fail;
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 result = (bool)(arg1)->LineDown();
31416
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 {
31421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31422 }
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31430 PyObject *resultobj;
31431 wxWindow *arg1 = (wxWindow *) 0 ;
31432 bool result;
31433 PyObject * obj0 = 0 ;
31434 char *kwnames[] = {
31435 (char *) "self", NULL
31436 };
31437
31438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31440 if (SWIG_arg_fail(1)) SWIG_fail;
31441 {
31442 PyThreadState* __tstate = wxPyBeginAllowThreads();
31443 result = (bool)(arg1)->PageUp();
31444
31445 wxPyEndAllowThreads(__tstate);
31446 if (PyErr_Occurred()) SWIG_fail;
31447 }
31448 {
31449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31450 }
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31458 PyObject *resultobj;
31459 wxWindow *arg1 = (wxWindow *) 0 ;
31460 bool result;
31461 PyObject * obj0 = 0 ;
31462 char *kwnames[] = {
31463 (char *) "self", NULL
31464 };
31465
31466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31468 if (SWIG_arg_fail(1)) SWIG_fail;
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (bool)(arg1)->PageDown();
31472
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 {
31477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31478 }
31479 return resultobj;
31480 fail:
31481 return NULL;
31482 }
31483
31484
31485 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31486 PyObject *resultobj;
31487 wxWindow *arg1 = (wxWindow *) 0 ;
31488 wxString *arg2 = 0 ;
31489 bool temp2 = false ;
31490 PyObject * obj0 = 0 ;
31491 PyObject * obj1 = 0 ;
31492 char *kwnames[] = {
31493 (char *) "self",(char *) "text", NULL
31494 };
31495
31496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31498 if (SWIG_arg_fail(1)) SWIG_fail;
31499 {
31500 arg2 = wxString_in_helper(obj1);
31501 if (arg2 == NULL) SWIG_fail;
31502 temp2 = true;
31503 }
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 (arg1)->SetHelpText((wxString const &)*arg2);
31507
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 Py_INCREF(Py_None); resultobj = Py_None;
31512 {
31513 if (temp2)
31514 delete arg2;
31515 }
31516 return resultobj;
31517 fail:
31518 {
31519 if (temp2)
31520 delete arg2;
31521 }
31522 return NULL;
31523 }
31524
31525
31526 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31527 PyObject *resultobj;
31528 wxWindow *arg1 = (wxWindow *) 0 ;
31529 wxString *arg2 = 0 ;
31530 bool temp2 = false ;
31531 PyObject * obj0 = 0 ;
31532 PyObject * obj1 = 0 ;
31533 char *kwnames[] = {
31534 (char *) "self",(char *) "text", NULL
31535 };
31536
31537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31539 if (SWIG_arg_fail(1)) SWIG_fail;
31540 {
31541 arg2 = wxString_in_helper(obj1);
31542 if (arg2 == NULL) SWIG_fail;
31543 temp2 = true;
31544 }
31545 {
31546 PyThreadState* __tstate = wxPyBeginAllowThreads();
31547 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31548
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 Py_INCREF(Py_None); resultobj = Py_None;
31553 {
31554 if (temp2)
31555 delete arg2;
31556 }
31557 return resultobj;
31558 fail:
31559 {
31560 if (temp2)
31561 delete arg2;
31562 }
31563 return NULL;
31564 }
31565
31566
31567 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31568 PyObject *resultobj;
31569 wxWindow *arg1 = (wxWindow *) 0 ;
31570 wxString result;
31571 PyObject * obj0 = 0 ;
31572 char *kwnames[] = {
31573 (char *) "self", NULL
31574 };
31575
31576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31578 if (SWIG_arg_fail(1)) SWIG_fail;
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = ((wxWindow const *)arg1)->GetHelpText();
31582
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 {
31587 #if wxUSE_UNICODE
31588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31589 #else
31590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31591 #endif
31592 }
31593 return resultobj;
31594 fail:
31595 return NULL;
31596 }
31597
31598
31599 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31600 PyObject *resultobj;
31601 wxWindow *arg1 = (wxWindow *) 0 ;
31602 wxString *arg2 = 0 ;
31603 bool temp2 = false ;
31604 PyObject * obj0 = 0 ;
31605 PyObject * obj1 = 0 ;
31606 char *kwnames[] = {
31607 (char *) "self",(char *) "tip", NULL
31608 };
31609
31610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",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 {
31614 arg2 = wxString_in_helper(obj1);
31615 if (arg2 == NULL) SWIG_fail;
31616 temp2 = true;
31617 }
31618 {
31619 PyThreadState* __tstate = wxPyBeginAllowThreads();
31620 (arg1)->SetToolTip((wxString const &)*arg2);
31621
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 Py_INCREF(Py_None); resultobj = Py_None;
31626 {
31627 if (temp2)
31628 delete arg2;
31629 }
31630 return resultobj;
31631 fail:
31632 {
31633 if (temp2)
31634 delete arg2;
31635 }
31636 return NULL;
31637 }
31638
31639
31640 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31641 PyObject *resultobj;
31642 wxWindow *arg1 = (wxWindow *) 0 ;
31643 wxToolTip *arg2 = (wxToolTip *) 0 ;
31644 PyObject * obj0 = 0 ;
31645 PyObject * obj1 = 0 ;
31646 char *kwnames[] = {
31647 (char *) "self",(char *) "tip", NULL
31648 };
31649
31650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31652 if (SWIG_arg_fail(1)) SWIG_fail;
31653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31654 if (SWIG_arg_fail(2)) SWIG_fail;
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 (arg1)->SetToolTip(arg2);
31658
31659 wxPyEndAllowThreads(__tstate);
31660 if (PyErr_Occurred()) SWIG_fail;
31661 }
31662 Py_INCREF(Py_None); resultobj = Py_None;
31663 return resultobj;
31664 fail:
31665 return NULL;
31666 }
31667
31668
31669 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31670 PyObject *resultobj;
31671 wxWindow *arg1 = (wxWindow *) 0 ;
31672 wxToolTip *result;
31673 PyObject * obj0 = 0 ;
31674 char *kwnames[] = {
31675 (char *) "self", NULL
31676 };
31677
31678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31680 if (SWIG_arg_fail(1)) SWIG_fail;
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31684
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 {
31689 resultobj = wxPyMake_wxObject(result, 0);
31690 }
31691 return resultobj;
31692 fail:
31693 return NULL;
31694 }
31695
31696
31697 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31698 PyObject *resultobj;
31699 wxWindow *arg1 = (wxWindow *) 0 ;
31700 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31701 PyObject * obj0 = 0 ;
31702 PyObject * obj1 = 0 ;
31703 char *kwnames[] = {
31704 (char *) "self",(char *) "dropTarget", NULL
31705 };
31706
31707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31709 if (SWIG_arg_fail(1)) SWIG_fail;
31710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31711 if (SWIG_arg_fail(2)) SWIG_fail;
31712 {
31713 PyThreadState* __tstate = wxPyBeginAllowThreads();
31714 (arg1)->SetDropTarget(arg2);
31715
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 Py_INCREF(Py_None); resultobj = Py_None;
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31727 PyObject *resultobj;
31728 wxWindow *arg1 = (wxWindow *) 0 ;
31729 wxPyDropTarget *result;
31730 PyObject * obj0 = 0 ;
31731 char *kwnames[] = {
31732 (char *) "self", NULL
31733 };
31734
31735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31737 if (SWIG_arg_fail(1)) SWIG_fail;
31738 {
31739 PyThreadState* __tstate = wxPyBeginAllowThreads();
31740 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31741
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31746 return resultobj;
31747 fail:
31748 return NULL;
31749 }
31750
31751
31752 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31753 PyObject *resultobj;
31754 wxWindow *arg1 = (wxWindow *) 0 ;
31755 bool arg2 ;
31756 PyObject * obj0 = 0 ;
31757 PyObject * obj1 = 0 ;
31758 char *kwnames[] = {
31759 (char *) "self",(char *) "accept", NULL
31760 };
31761
31762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31764 if (SWIG_arg_fail(1)) SWIG_fail;
31765 {
31766 arg2 = (bool)(SWIG_As_bool(obj1));
31767 if (SWIG_arg_fail(2)) SWIG_fail;
31768 }
31769 {
31770 PyThreadState* __tstate = wxPyBeginAllowThreads();
31771 (arg1)->DragAcceptFiles(arg2);
31772
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 Py_INCREF(Py_None); resultobj = Py_None;
31777 return resultobj;
31778 fail:
31779 return NULL;
31780 }
31781
31782
31783 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31784 PyObject *resultobj;
31785 wxWindow *arg1 = (wxWindow *) 0 ;
31786 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31787 PyObject * obj0 = 0 ;
31788 PyObject * obj1 = 0 ;
31789 char *kwnames[] = {
31790 (char *) "self",(char *) "constraints", NULL
31791 };
31792
31793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31795 if (SWIG_arg_fail(1)) SWIG_fail;
31796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31797 if (SWIG_arg_fail(2)) SWIG_fail;
31798 {
31799 PyThreadState* __tstate = wxPyBeginAllowThreads();
31800 (arg1)->SetConstraints(arg2);
31801
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 Py_INCREF(Py_None); resultobj = Py_None;
31806 return resultobj;
31807 fail:
31808 return NULL;
31809 }
31810
31811
31812 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31813 PyObject *resultobj;
31814 wxWindow *arg1 = (wxWindow *) 0 ;
31815 wxLayoutConstraints *result;
31816 PyObject * obj0 = 0 ;
31817 char *kwnames[] = {
31818 (char *) "self", NULL
31819 };
31820
31821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31823 if (SWIG_arg_fail(1)) SWIG_fail;
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31827
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31832 return resultobj;
31833 fail:
31834 return NULL;
31835 }
31836
31837
31838 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31839 PyObject *resultobj;
31840 wxWindow *arg1 = (wxWindow *) 0 ;
31841 bool arg2 ;
31842 PyObject * obj0 = 0 ;
31843 PyObject * obj1 = 0 ;
31844 char *kwnames[] = {
31845 (char *) "self",(char *) "autoLayout", NULL
31846 };
31847
31848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31850 if (SWIG_arg_fail(1)) SWIG_fail;
31851 {
31852 arg2 = (bool)(SWIG_As_bool(obj1));
31853 if (SWIG_arg_fail(2)) SWIG_fail;
31854 }
31855 {
31856 PyThreadState* __tstate = wxPyBeginAllowThreads();
31857 (arg1)->SetAutoLayout(arg2);
31858
31859 wxPyEndAllowThreads(__tstate);
31860 if (PyErr_Occurred()) SWIG_fail;
31861 }
31862 Py_INCREF(Py_None); resultobj = Py_None;
31863 return resultobj;
31864 fail:
31865 return NULL;
31866 }
31867
31868
31869 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31870 PyObject *resultobj;
31871 wxWindow *arg1 = (wxWindow *) 0 ;
31872 bool result;
31873 PyObject * obj0 = 0 ;
31874 char *kwnames[] = {
31875 (char *) "self", NULL
31876 };
31877
31878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31880 if (SWIG_arg_fail(1)) SWIG_fail;
31881 {
31882 PyThreadState* __tstate = wxPyBeginAllowThreads();
31883 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31884
31885 wxPyEndAllowThreads(__tstate);
31886 if (PyErr_Occurred()) SWIG_fail;
31887 }
31888 {
31889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31890 }
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj;
31899 wxWindow *arg1 = (wxWindow *) 0 ;
31900 bool result;
31901 PyObject * obj0 = 0 ;
31902 char *kwnames[] = {
31903 (char *) "self", NULL
31904 };
31905
31906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31908 if (SWIG_arg_fail(1)) SWIG_fail;
31909 {
31910 PyThreadState* __tstate = wxPyBeginAllowThreads();
31911 result = (bool)(arg1)->Layout();
31912
31913 wxPyEndAllowThreads(__tstate);
31914 if (PyErr_Occurred()) SWIG_fail;
31915 }
31916 {
31917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31918 }
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31926 PyObject *resultobj;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSizer *arg2 = (wxSizer *) 0 ;
31929 bool arg3 = (bool) true ;
31930 PyObject * obj0 = 0 ;
31931 PyObject * obj1 = 0 ;
31932 PyObject * obj2 = 0 ;
31933 char *kwnames[] = {
31934 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31935 };
31936
31937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31941 if (SWIG_arg_fail(2)) SWIG_fail;
31942 if (obj2) {
31943 {
31944 arg3 = (bool)(SWIG_As_bool(obj2));
31945 if (SWIG_arg_fail(3)) SWIG_fail;
31946 }
31947 }
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 (arg1)->SetSizer(arg2,arg3);
31951
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 Py_INCREF(Py_None); resultobj = Py_None;
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31963 PyObject *resultobj;
31964 wxWindow *arg1 = (wxWindow *) 0 ;
31965 wxSizer *arg2 = (wxSizer *) 0 ;
31966 bool arg3 = (bool) true ;
31967 PyObject * obj0 = 0 ;
31968 PyObject * obj1 = 0 ;
31969 PyObject * obj2 = 0 ;
31970 char *kwnames[] = {
31971 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31972 };
31973
31974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31976 if (SWIG_arg_fail(1)) SWIG_fail;
31977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31978 if (SWIG_arg_fail(2)) SWIG_fail;
31979 if (obj2) {
31980 {
31981 arg3 = (bool)(SWIG_As_bool(obj2));
31982 if (SWIG_arg_fail(3)) SWIG_fail;
31983 }
31984 }
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 (arg1)->SetSizerAndFit(arg2,arg3);
31988
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 Py_INCREF(Py_None); resultobj = Py_None;
31993 return resultobj;
31994 fail:
31995 return NULL;
31996 }
31997
31998
31999 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32000 PyObject *resultobj;
32001 wxWindow *arg1 = (wxWindow *) 0 ;
32002 wxSizer *result;
32003 PyObject * obj0 = 0 ;
32004 char *kwnames[] = {
32005 (char *) "self", NULL
32006 };
32007
32008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32010 if (SWIG_arg_fail(1)) SWIG_fail;
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32014
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 {
32019 resultobj = wxPyMake_wxSizer(result, 0);
32020 }
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32028 PyObject *resultobj;
32029 wxWindow *arg1 = (wxWindow *) 0 ;
32030 wxSizer *arg2 = (wxSizer *) 0 ;
32031 PyObject * obj0 = 0 ;
32032 PyObject * obj1 = 0 ;
32033 char *kwnames[] = {
32034 (char *) "self",(char *) "sizer", NULL
32035 };
32036
32037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32039 if (SWIG_arg_fail(1)) SWIG_fail;
32040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32041 if (SWIG_arg_fail(2)) SWIG_fail;
32042 {
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 (arg1)->SetContainingSizer(arg2);
32045
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 Py_INCREF(Py_None); resultobj = Py_None;
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32057 PyObject *resultobj;
32058 wxWindow *arg1 = (wxWindow *) 0 ;
32059 wxSizer *result;
32060 PyObject * obj0 = 0 ;
32061 char *kwnames[] = {
32062 (char *) "self", NULL
32063 };
32064
32065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32067 if (SWIG_arg_fail(1)) SWIG_fail;
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32071
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 {
32076 resultobj = wxPyMake_wxSizer(result, 0);
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32085 PyObject *resultobj;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 PyObject * obj0 = 0 ;
32088 char *kwnames[] = {
32089 (char *) "self", NULL
32090 };
32091
32092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32094 if (SWIG_arg_fail(1)) SWIG_fail;
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 (arg1)->InheritAttributes();
32098
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 Py_INCREF(Py_None); resultobj = Py_None;
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32110 PyObject *resultobj;
32111 wxWindow *arg1 = (wxWindow *) 0 ;
32112 bool result;
32113 PyObject * obj0 = 0 ;
32114 char *kwnames[] = {
32115 (char *) "self", NULL
32116 };
32117
32118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32120 if (SWIG_arg_fail(1)) SWIG_fail;
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32124
32125 wxPyEndAllowThreads(__tstate);
32126 if (PyErr_Occurred()) SWIG_fail;
32127 }
32128 {
32129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32130 }
32131 return resultobj;
32132 fail:
32133 return NULL;
32134 }
32135
32136
32137 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32138 PyObject *obj;
32139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32140 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32141 Py_INCREF(obj);
32142 return Py_BuildValue((char *)"");
32143 }
32144 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32145 PyObject *resultobj;
32146 long arg1 ;
32147 wxWindow *arg2 = (wxWindow *) NULL ;
32148 wxWindow *result;
32149 PyObject * obj0 = 0 ;
32150 PyObject * obj1 = 0 ;
32151 char *kwnames[] = {
32152 (char *) "id",(char *) "parent", NULL
32153 };
32154
32155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32156 {
32157 arg1 = (long)(SWIG_As_long(obj0));
32158 if (SWIG_arg_fail(1)) SWIG_fail;
32159 }
32160 if (obj1) {
32161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32162 if (SWIG_arg_fail(2)) SWIG_fail;
32163 }
32164 {
32165 if (!wxPyCheckForApp()) SWIG_fail;
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)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_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj;
32183 wxString *arg1 = 0 ;
32184 wxWindow *arg2 = (wxWindow *) NULL ;
32185 wxWindow *result;
32186 bool temp1 = false ;
32187 PyObject * obj0 = 0 ;
32188 PyObject * obj1 = 0 ;
32189 char *kwnames[] = {
32190 (char *) "name",(char *) "parent", NULL
32191 };
32192
32193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32194 {
32195 arg1 = wxString_in_helper(obj0);
32196 if (arg1 == NULL) SWIG_fail;
32197 temp1 = true;
32198 }
32199 if (obj1) {
32200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32201 if (SWIG_arg_fail(2)) SWIG_fail;
32202 }
32203 {
32204 if (!wxPyCheckForApp()) SWIG_fail;
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32207
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 {
32212 resultobj = wxPyMake_wxObject(result, 0);
32213 }
32214 {
32215 if (temp1)
32216 delete arg1;
32217 }
32218 return resultobj;
32219 fail:
32220 {
32221 if (temp1)
32222 delete arg1;
32223 }
32224 return NULL;
32225 }
32226
32227
32228 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32229 PyObject *resultobj;
32230 wxString *arg1 = 0 ;
32231 wxWindow *arg2 = (wxWindow *) NULL ;
32232 wxWindow *result;
32233 bool temp1 = false ;
32234 PyObject * obj0 = 0 ;
32235 PyObject * obj1 = 0 ;
32236 char *kwnames[] = {
32237 (char *) "label",(char *) "parent", NULL
32238 };
32239
32240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32241 {
32242 arg1 = wxString_in_helper(obj0);
32243 if (arg1 == NULL) SWIG_fail;
32244 temp1 = true;
32245 }
32246 if (obj1) {
32247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32248 if (SWIG_arg_fail(2)) SWIG_fail;
32249 }
32250 {
32251 if (!wxPyCheckForApp()) SWIG_fail;
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32254
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 {
32259 resultobj = wxPyMake_wxObject(result, 0);
32260 }
32261 {
32262 if (temp1)
32263 delete arg1;
32264 }
32265 return resultobj;
32266 fail:
32267 {
32268 if (temp1)
32269 delete arg1;
32270 }
32271 return NULL;
32272 }
32273
32274
32275 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32276 PyObject *resultobj;
32277 wxWindow *arg1 = (wxWindow *) 0 ;
32278 unsigned long arg2 ;
32279 wxWindow *result;
32280 PyObject * obj0 = 0 ;
32281 PyObject * obj1 = 0 ;
32282 char *kwnames[] = {
32283 (char *) "parent",(char *) "_hWnd", NULL
32284 };
32285
32286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32288 if (SWIG_arg_fail(1)) SWIG_fail;
32289 {
32290 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32291 if (SWIG_arg_fail(2)) SWIG_fail;
32292 }
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32296
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 {
32301 resultobj = wxPyMake_wxObject(result, 0);
32302 }
32303 return resultobj;
32304 fail:
32305 return NULL;
32306 }
32307
32308
32309 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32310 PyObject *resultobj;
32311 PyObject *result;
32312 char *kwnames[] = {
32313 NULL
32314 };
32315
32316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (PyObject *)GetTopLevelWindows();
32320
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 resultobj = result;
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj;
32333 wxValidator *result;
32334 char *kwnames[] = {
32335 NULL
32336 };
32337
32338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32339 {
32340 PyThreadState* __tstate = wxPyBeginAllowThreads();
32341 result = (wxValidator *)new wxValidator();
32342
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32347 return resultobj;
32348 fail:
32349 return NULL;
32350 }
32351
32352
32353 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32354 PyObject *resultobj;
32355 wxValidator *arg1 = (wxValidator *) 0 ;
32356 wxValidator *result;
32357 PyObject * obj0 = 0 ;
32358 char *kwnames[] = {
32359 (char *) "self", NULL
32360 };
32361
32362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32364 if (SWIG_arg_fail(1)) SWIG_fail;
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 result = (wxValidator *)(arg1)->Clone();
32368
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 {
32373 resultobj = wxPyMake_wxObject(result, 0);
32374 }
32375 return resultobj;
32376 fail:
32377 return NULL;
32378 }
32379
32380
32381 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32382 PyObject *resultobj;
32383 wxValidator *arg1 = (wxValidator *) 0 ;
32384 wxWindow *arg2 = (wxWindow *) 0 ;
32385 bool result;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 char *kwnames[] = {
32389 (char *) "self",(char *) "parent", NULL
32390 };
32391
32392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32394 if (SWIG_arg_fail(1)) SWIG_fail;
32395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32396 if (SWIG_arg_fail(2)) SWIG_fail;
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 result = (bool)(arg1)->Validate(arg2);
32400
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 {
32405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32406 }
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj;
32415 wxValidator *arg1 = (wxValidator *) 0 ;
32416 bool result;
32417 PyObject * obj0 = 0 ;
32418 char *kwnames[] = {
32419 (char *) "self", NULL
32420 };
32421
32422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32424 if (SWIG_arg_fail(1)) SWIG_fail;
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (bool)(arg1)->TransferToWindow();
32428
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 {
32433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj;
32443 wxValidator *arg1 = (wxValidator *) 0 ;
32444 bool result;
32445 PyObject * obj0 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "self", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32452 if (SWIG_arg_fail(1)) SWIG_fail;
32453 {
32454 PyThreadState* __tstate = wxPyBeginAllowThreads();
32455 result = (bool)(arg1)->TransferFromWindow();
32456
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 {
32461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj;
32471 wxValidator *arg1 = (wxValidator *) 0 ;
32472 wxWindow *result;
32473 PyObject * obj0 = 0 ;
32474 char *kwnames[] = {
32475 (char *) "self", NULL
32476 };
32477
32478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32480 if (SWIG_arg_fail(1)) SWIG_fail;
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 result = (wxWindow *)(arg1)->GetWindow();
32484
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 {
32489 resultobj = wxPyMake_wxObject(result, 0);
32490 }
32491 return resultobj;
32492 fail:
32493 return NULL;
32494 }
32495
32496
32497 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32498 PyObject *resultobj;
32499 wxValidator *arg1 = (wxValidator *) 0 ;
32500 wxWindow *arg2 = (wxWindow *) 0 ;
32501 PyObject * obj0 = 0 ;
32502 PyObject * obj1 = 0 ;
32503 char *kwnames[] = {
32504 (char *) "self",(char *) "window", NULL
32505 };
32506
32507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32509 if (SWIG_arg_fail(1)) SWIG_fail;
32510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32511 if (SWIG_arg_fail(2)) SWIG_fail;
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 (arg1)->SetWindow(arg2);
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 Py_INCREF(Py_None); resultobj = Py_None;
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj;
32528 bool result;
32529 char *kwnames[] = {
32530 NULL
32531 };
32532
32533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32534 {
32535 PyThreadState* __tstate = wxPyBeginAllowThreads();
32536 result = (bool)wxValidator::IsSilent();
32537
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 {
32542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32543 }
32544 return resultobj;
32545 fail:
32546 return NULL;
32547 }
32548
32549
32550 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32551 PyObject *resultobj;
32552 int arg1 = (int) true ;
32553 PyObject * obj0 = 0 ;
32554 char *kwnames[] = {
32555 (char *) "doIt", NULL
32556 };
32557
32558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32559 if (obj0) {
32560 {
32561 arg1 = (int)(SWIG_As_int(obj0));
32562 if (SWIG_arg_fail(1)) SWIG_fail;
32563 }
32564 }
32565 {
32566 PyThreadState* __tstate = wxPyBeginAllowThreads();
32567 wxValidator::SetBellOnError(arg1);
32568
32569 wxPyEndAllowThreads(__tstate);
32570 if (PyErr_Occurred()) SWIG_fail;
32571 }
32572 Py_INCREF(Py_None); resultobj = Py_None;
32573 return resultobj;
32574 fail:
32575 return NULL;
32576 }
32577
32578
32579 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32580 PyObject *obj;
32581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32582 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32583 Py_INCREF(obj);
32584 return Py_BuildValue((char *)"");
32585 }
32586 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32587 PyObject *resultobj;
32588 wxPyValidator *result;
32589 char *kwnames[] = {
32590 NULL
32591 };
32592
32593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32594 {
32595 PyThreadState* __tstate = wxPyBeginAllowThreads();
32596 result = (wxPyValidator *)new wxPyValidator();
32597
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32609 PyObject *resultobj;
32610 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32611 PyObject *arg2 = (PyObject *) 0 ;
32612 PyObject *arg3 = (PyObject *) 0 ;
32613 int arg4 = (int) true ;
32614 PyObject * obj0 = 0 ;
32615 PyObject * obj1 = 0 ;
32616 PyObject * obj2 = 0 ;
32617 PyObject * obj3 = 0 ;
32618 char *kwnames[] = {
32619 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32620 };
32621
32622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32624 if (SWIG_arg_fail(1)) SWIG_fail;
32625 arg2 = obj1;
32626 arg3 = obj2;
32627 if (obj3) {
32628 {
32629 arg4 = (int)(SWIG_As_int(obj3));
32630 if (SWIG_arg_fail(4)) SWIG_fail;
32631 }
32632 }
32633 {
32634 PyThreadState* __tstate = wxPyBeginAllowThreads();
32635 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32636
32637 wxPyEndAllowThreads(__tstate);
32638 if (PyErr_Occurred()) SWIG_fail;
32639 }
32640 Py_INCREF(Py_None); resultobj = Py_None;
32641 return resultobj;
32642 fail:
32643 return NULL;
32644 }
32645
32646
32647 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32648 PyObject *obj;
32649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32650 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32651 Py_INCREF(obj);
32652 return Py_BuildValue((char *)"");
32653 }
32654 static int _wrap_DefaultValidator_set(PyObject *) {
32655 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32656 return 1;
32657 }
32658
32659
32660 static PyObject *_wrap_DefaultValidator_get(void) {
32661 PyObject *pyobj;
32662
32663 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32664 return pyobj;
32665 }
32666
32667
32668 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32669 PyObject *resultobj;
32670 wxString const &arg1_defvalue = wxPyEmptyString ;
32671 wxString *arg1 = (wxString *) &arg1_defvalue ;
32672 long arg2 = (long) 0 ;
32673 wxMenu *result;
32674 bool temp1 = false ;
32675 PyObject * obj0 = 0 ;
32676 PyObject * obj1 = 0 ;
32677 char *kwnames[] = {
32678 (char *) "title",(char *) "style", NULL
32679 };
32680
32681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32682 if (obj0) {
32683 {
32684 arg1 = wxString_in_helper(obj0);
32685 if (arg1 == NULL) SWIG_fail;
32686 temp1 = true;
32687 }
32688 }
32689 if (obj1) {
32690 {
32691 arg2 = (long)(SWIG_As_long(obj1));
32692 if (SWIG_arg_fail(2)) SWIG_fail;
32693 }
32694 }
32695 {
32696 if (!wxPyCheckForApp()) SWIG_fail;
32697 PyThreadState* __tstate = wxPyBeginAllowThreads();
32698 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32699
32700 wxPyEndAllowThreads(__tstate);
32701 if (PyErr_Occurred()) SWIG_fail;
32702 }
32703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32704 {
32705 if (temp1)
32706 delete arg1;
32707 }
32708 return resultobj;
32709 fail:
32710 {
32711 if (temp1)
32712 delete arg1;
32713 }
32714 return NULL;
32715 }
32716
32717
32718 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32719 PyObject *resultobj;
32720 wxMenu *arg1 = (wxMenu *) 0 ;
32721 int arg2 ;
32722 wxString *arg3 = 0 ;
32723 wxString const &arg4_defvalue = wxPyEmptyString ;
32724 wxString *arg4 = (wxString *) &arg4_defvalue ;
32725 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32726 wxMenuItem *result;
32727 bool temp3 = false ;
32728 bool temp4 = false ;
32729 PyObject * obj0 = 0 ;
32730 PyObject * obj1 = 0 ;
32731 PyObject * obj2 = 0 ;
32732 PyObject * obj3 = 0 ;
32733 PyObject * obj4 = 0 ;
32734 char *kwnames[] = {
32735 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32736 };
32737
32738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32740 if (SWIG_arg_fail(1)) SWIG_fail;
32741 {
32742 arg2 = (int)(SWIG_As_int(obj1));
32743 if (SWIG_arg_fail(2)) SWIG_fail;
32744 }
32745 {
32746 arg3 = wxString_in_helper(obj2);
32747 if (arg3 == NULL) SWIG_fail;
32748 temp3 = true;
32749 }
32750 if (obj3) {
32751 {
32752 arg4 = wxString_in_helper(obj3);
32753 if (arg4 == NULL) SWIG_fail;
32754 temp4 = true;
32755 }
32756 }
32757 if (obj4) {
32758 {
32759 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32760 if (SWIG_arg_fail(5)) SWIG_fail;
32761 }
32762 }
32763 {
32764 PyThreadState* __tstate = wxPyBeginAllowThreads();
32765 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32766
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 {
32771 resultobj = wxPyMake_wxObject(result, 0);
32772 }
32773 {
32774 if (temp3)
32775 delete arg3;
32776 }
32777 {
32778 if (temp4)
32779 delete arg4;
32780 }
32781 return resultobj;
32782 fail:
32783 {
32784 if (temp3)
32785 delete arg3;
32786 }
32787 {
32788 if (temp4)
32789 delete arg4;
32790 }
32791 return NULL;
32792 }
32793
32794
32795 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj;
32797 wxMenu *arg1 = (wxMenu *) 0 ;
32798 wxMenuItem *result;
32799 PyObject * obj0 = 0 ;
32800 char *kwnames[] = {
32801 (char *) "self", NULL
32802 };
32803
32804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32806 if (SWIG_arg_fail(1)) SWIG_fail;
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 result = (wxMenuItem *)(arg1)->AppendSeparator();
32810
32811 wxPyEndAllowThreads(__tstate);
32812 if (PyErr_Occurred()) SWIG_fail;
32813 }
32814 {
32815 resultobj = wxPyMake_wxObject(result, 0);
32816 }
32817 return resultobj;
32818 fail:
32819 return NULL;
32820 }
32821
32822
32823 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32824 PyObject *resultobj;
32825 wxMenu *arg1 = (wxMenu *) 0 ;
32826 int arg2 ;
32827 wxString *arg3 = 0 ;
32828 wxString const &arg4_defvalue = wxPyEmptyString ;
32829 wxString *arg4 = (wxString *) &arg4_defvalue ;
32830 wxMenuItem *result;
32831 bool temp3 = false ;
32832 bool temp4 = false ;
32833 PyObject * obj0 = 0 ;
32834 PyObject * obj1 = 0 ;
32835 PyObject * obj2 = 0 ;
32836 PyObject * obj3 = 0 ;
32837 char *kwnames[] = {
32838 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32839 };
32840
32841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32843 if (SWIG_arg_fail(1)) SWIG_fail;
32844 {
32845 arg2 = (int)(SWIG_As_int(obj1));
32846 if (SWIG_arg_fail(2)) SWIG_fail;
32847 }
32848 {
32849 arg3 = wxString_in_helper(obj2);
32850 if (arg3 == NULL) SWIG_fail;
32851 temp3 = true;
32852 }
32853 if (obj3) {
32854 {
32855 arg4 = wxString_in_helper(obj3);
32856 if (arg4 == NULL) SWIG_fail;
32857 temp4 = true;
32858 }
32859 }
32860 {
32861 PyThreadState* __tstate = wxPyBeginAllowThreads();
32862 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32863
32864 wxPyEndAllowThreads(__tstate);
32865 if (PyErr_Occurred()) SWIG_fail;
32866 }
32867 {
32868 resultobj = wxPyMake_wxObject(result, 0);
32869 }
32870 {
32871 if (temp3)
32872 delete arg3;
32873 }
32874 {
32875 if (temp4)
32876 delete arg4;
32877 }
32878 return resultobj;
32879 fail:
32880 {
32881 if (temp3)
32882 delete arg3;
32883 }
32884 {
32885 if (temp4)
32886 delete arg4;
32887 }
32888 return NULL;
32889 }
32890
32891
32892 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32893 PyObject *resultobj;
32894 wxMenu *arg1 = (wxMenu *) 0 ;
32895 int arg2 ;
32896 wxString *arg3 = 0 ;
32897 wxString const &arg4_defvalue = wxPyEmptyString ;
32898 wxString *arg4 = (wxString *) &arg4_defvalue ;
32899 wxMenuItem *result;
32900 bool temp3 = false ;
32901 bool temp4 = false ;
32902 PyObject * obj0 = 0 ;
32903 PyObject * obj1 = 0 ;
32904 PyObject * obj2 = 0 ;
32905 PyObject * obj3 = 0 ;
32906 char *kwnames[] = {
32907 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32908 };
32909
32910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32912 if (SWIG_arg_fail(1)) SWIG_fail;
32913 {
32914 arg2 = (int)(SWIG_As_int(obj1));
32915 if (SWIG_arg_fail(2)) SWIG_fail;
32916 }
32917 {
32918 arg3 = wxString_in_helper(obj2);
32919 if (arg3 == NULL) SWIG_fail;
32920 temp3 = true;
32921 }
32922 if (obj3) {
32923 {
32924 arg4 = wxString_in_helper(obj3);
32925 if (arg4 == NULL) SWIG_fail;
32926 temp4 = true;
32927 }
32928 }
32929 {
32930 PyThreadState* __tstate = wxPyBeginAllowThreads();
32931 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32932
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 {
32937 resultobj = wxPyMake_wxObject(result, 0);
32938 }
32939 {
32940 if (temp3)
32941 delete arg3;
32942 }
32943 {
32944 if (temp4)
32945 delete arg4;
32946 }
32947 return resultobj;
32948 fail:
32949 {
32950 if (temp3)
32951 delete arg3;
32952 }
32953 {
32954 if (temp4)
32955 delete arg4;
32956 }
32957 return NULL;
32958 }
32959
32960
32961 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32962 PyObject *resultobj;
32963 wxMenu *arg1 = (wxMenu *) 0 ;
32964 int arg2 ;
32965 wxString *arg3 = 0 ;
32966 wxMenu *arg4 = (wxMenu *) 0 ;
32967 wxString const &arg5_defvalue = wxPyEmptyString ;
32968 wxString *arg5 = (wxString *) &arg5_defvalue ;
32969 wxMenuItem *result;
32970 bool temp3 = false ;
32971 bool temp5 = false ;
32972 PyObject * obj0 = 0 ;
32973 PyObject * obj1 = 0 ;
32974 PyObject * obj2 = 0 ;
32975 PyObject * obj3 = 0 ;
32976 PyObject * obj4 = 0 ;
32977 char *kwnames[] = {
32978 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32979 };
32980
32981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32983 if (SWIG_arg_fail(1)) SWIG_fail;
32984 {
32985 arg2 = (int)(SWIG_As_int(obj1));
32986 if (SWIG_arg_fail(2)) SWIG_fail;
32987 }
32988 {
32989 arg3 = wxString_in_helper(obj2);
32990 if (arg3 == NULL) SWIG_fail;
32991 temp3 = true;
32992 }
32993 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32994 if (SWIG_arg_fail(4)) SWIG_fail;
32995 if (obj4) {
32996 {
32997 arg5 = wxString_in_helper(obj4);
32998 if (arg5 == NULL) SWIG_fail;
32999 temp5 = true;
33000 }
33001 }
33002 {
33003 PyThreadState* __tstate = wxPyBeginAllowThreads();
33004 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33005
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 {
33010 resultobj = wxPyMake_wxObject(result, 0);
33011 }
33012 {
33013 if (temp3)
33014 delete arg3;
33015 }
33016 {
33017 if (temp5)
33018 delete arg5;
33019 }
33020 return resultobj;
33021 fail:
33022 {
33023 if (temp3)
33024 delete arg3;
33025 }
33026 {
33027 if (temp5)
33028 delete arg5;
33029 }
33030 return NULL;
33031 }
33032
33033
33034 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33035 PyObject *resultobj;
33036 wxMenu *arg1 = (wxMenu *) 0 ;
33037 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33038 wxMenuItem *result;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char *kwnames[] = {
33042 (char *) "self",(char *) "item", NULL
33043 };
33044
33045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33047 if (SWIG_arg_fail(1)) SWIG_fail;
33048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33049 if (SWIG_arg_fail(2)) SWIG_fail;
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 result = (wxMenuItem *)(arg1)->Append(arg2);
33053
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 {
33058 resultobj = wxPyMake_wxObject(result, 0);
33059 }
33060 return resultobj;
33061 fail:
33062 return NULL;
33063 }
33064
33065
33066 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33067 PyObject *resultobj;
33068 wxMenu *arg1 = (wxMenu *) 0 ;
33069 PyObject * obj0 = 0 ;
33070 char *kwnames[] = {
33071 (char *) "self", NULL
33072 };
33073
33074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33076 if (SWIG_arg_fail(1)) SWIG_fail;
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 (arg1)->Break();
33080
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 Py_INCREF(Py_None); resultobj = Py_None;
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33092 PyObject *resultobj;
33093 wxMenu *arg1 = (wxMenu *) 0 ;
33094 size_t arg2 ;
33095 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33096 wxMenuItem *result;
33097 PyObject * obj0 = 0 ;
33098 PyObject * obj1 = 0 ;
33099 PyObject * obj2 = 0 ;
33100 char *kwnames[] = {
33101 (char *) "self",(char *) "pos",(char *) "item", NULL
33102 };
33103
33104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33106 if (SWIG_arg_fail(1)) SWIG_fail;
33107 {
33108 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33109 if (SWIG_arg_fail(2)) SWIG_fail;
33110 }
33111 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33112 if (SWIG_arg_fail(3)) SWIG_fail;
33113 {
33114 PyThreadState* __tstate = wxPyBeginAllowThreads();
33115 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33116
33117 wxPyEndAllowThreads(__tstate);
33118 if (PyErr_Occurred()) SWIG_fail;
33119 }
33120 {
33121 resultobj = wxPyMake_wxObject(result, 0);
33122 }
33123 return resultobj;
33124 fail:
33125 return NULL;
33126 }
33127
33128
33129 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33130 PyObject *resultobj;
33131 wxMenu *arg1 = (wxMenu *) 0 ;
33132 size_t arg2 ;
33133 int arg3 ;
33134 wxString *arg4 = 0 ;
33135 wxString const &arg5_defvalue = wxPyEmptyString ;
33136 wxString *arg5 = (wxString *) &arg5_defvalue ;
33137 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33138 wxMenuItem *result;
33139 bool temp4 = false ;
33140 bool temp5 = false ;
33141 PyObject * obj0 = 0 ;
33142 PyObject * obj1 = 0 ;
33143 PyObject * obj2 = 0 ;
33144 PyObject * obj3 = 0 ;
33145 PyObject * obj4 = 0 ;
33146 PyObject * obj5 = 0 ;
33147 char *kwnames[] = {
33148 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33149 };
33150
33151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33153 if (SWIG_arg_fail(1)) SWIG_fail;
33154 {
33155 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33156 if (SWIG_arg_fail(2)) SWIG_fail;
33157 }
33158 {
33159 arg3 = (int)(SWIG_As_int(obj2));
33160 if (SWIG_arg_fail(3)) SWIG_fail;
33161 }
33162 {
33163 arg4 = wxString_in_helper(obj3);
33164 if (arg4 == NULL) SWIG_fail;
33165 temp4 = true;
33166 }
33167 if (obj4) {
33168 {
33169 arg5 = wxString_in_helper(obj4);
33170 if (arg5 == NULL) SWIG_fail;
33171 temp5 = true;
33172 }
33173 }
33174 if (obj5) {
33175 {
33176 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33177 if (SWIG_arg_fail(6)) SWIG_fail;
33178 }
33179 }
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33183
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 resultobj = wxPyMake_wxObject(result, 0);
33189 }
33190 {
33191 if (temp4)
33192 delete arg4;
33193 }
33194 {
33195 if (temp5)
33196 delete arg5;
33197 }
33198 return resultobj;
33199 fail:
33200 {
33201 if (temp4)
33202 delete arg4;
33203 }
33204 {
33205 if (temp5)
33206 delete arg5;
33207 }
33208 return NULL;
33209 }
33210
33211
33212 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj;
33214 wxMenu *arg1 = (wxMenu *) 0 ;
33215 size_t arg2 ;
33216 wxMenuItem *result;
33217 PyObject * obj0 = 0 ;
33218 PyObject * obj1 = 0 ;
33219 char *kwnames[] = {
33220 (char *) "self",(char *) "pos", NULL
33221 };
33222
33223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33225 if (SWIG_arg_fail(1)) SWIG_fail;
33226 {
33227 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33228 if (SWIG_arg_fail(2)) SWIG_fail;
33229 }
33230 {
33231 PyThreadState* __tstate = wxPyBeginAllowThreads();
33232 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33233
33234 wxPyEndAllowThreads(__tstate);
33235 if (PyErr_Occurred()) SWIG_fail;
33236 }
33237 {
33238 resultobj = wxPyMake_wxObject(result, 0);
33239 }
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 static PyObject *_wrap_Menu_InsertCheckItem(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 wxString const &arg5_defvalue = wxPyEmptyString ;
33253 wxString *arg5 = (wxString *) &arg5_defvalue ;
33254 wxMenuItem *result;
33255 bool temp4 = false ;
33256 bool temp5 = false ;
33257 PyObject * obj0 = 0 ;
33258 PyObject * obj1 = 0 ;
33259 PyObject * obj2 = 0 ;
33260 PyObject * obj3 = 0 ;
33261 PyObject * obj4 = 0 ;
33262 char *kwnames[] = {
33263 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33264 };
33265
33266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33268 if (SWIG_arg_fail(1)) SWIG_fail;
33269 {
33270 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33271 if (SWIG_arg_fail(2)) SWIG_fail;
33272 }
33273 {
33274 arg3 = (int)(SWIG_As_int(obj2));
33275 if (SWIG_arg_fail(3)) SWIG_fail;
33276 }
33277 {
33278 arg4 = wxString_in_helper(obj3);
33279 if (arg4 == NULL) SWIG_fail;
33280 temp4 = true;
33281 }
33282 if (obj4) {
33283 {
33284 arg5 = wxString_in_helper(obj4);
33285 if (arg5 == NULL) SWIG_fail;
33286 temp5 = true;
33287 }
33288 }
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33292
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 {
33297 resultobj = wxPyMake_wxObject(result, 0);
33298 }
33299 {
33300 if (temp4)
33301 delete arg4;
33302 }
33303 {
33304 if (temp5)
33305 delete arg5;
33306 }
33307 return resultobj;
33308 fail:
33309 {
33310 if (temp4)
33311 delete arg4;
33312 }
33313 {
33314 if (temp5)
33315 delete arg5;
33316 }
33317 return NULL;
33318 }
33319
33320
33321 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33322 PyObject *resultobj;
33323 wxMenu *arg1 = (wxMenu *) 0 ;
33324 size_t arg2 ;
33325 int arg3 ;
33326 wxString *arg4 = 0 ;
33327 wxString const &arg5_defvalue = wxPyEmptyString ;
33328 wxString *arg5 = (wxString *) &arg5_defvalue ;
33329 wxMenuItem *result;
33330 bool temp4 = false ;
33331 bool temp5 = false ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 PyObject * obj2 = 0 ;
33335 PyObject * obj3 = 0 ;
33336 PyObject * obj4 = 0 ;
33337 char *kwnames[] = {
33338 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33339 };
33340
33341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33343 if (SWIG_arg_fail(1)) SWIG_fail;
33344 {
33345 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33346 if (SWIG_arg_fail(2)) SWIG_fail;
33347 }
33348 {
33349 arg3 = (int)(SWIG_As_int(obj2));
33350 if (SWIG_arg_fail(3)) SWIG_fail;
33351 }
33352 {
33353 arg4 = wxString_in_helper(obj3);
33354 if (arg4 == NULL) SWIG_fail;
33355 temp4 = true;
33356 }
33357 if (obj4) {
33358 {
33359 arg5 = wxString_in_helper(obj4);
33360 if (arg5 == NULL) SWIG_fail;
33361 temp5 = true;
33362 }
33363 }
33364 {
33365 PyThreadState* __tstate = wxPyBeginAllowThreads();
33366 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33367
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 {
33372 resultobj = wxPyMake_wxObject(result, 0);
33373 }
33374 {
33375 if (temp4)
33376 delete arg4;
33377 }
33378 {
33379 if (temp5)
33380 delete arg5;
33381 }
33382 return resultobj;
33383 fail:
33384 {
33385 if (temp4)
33386 delete arg4;
33387 }
33388 {
33389 if (temp5)
33390 delete arg5;
33391 }
33392 return NULL;
33393 }
33394
33395
33396 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33397 PyObject *resultobj;
33398 wxMenu *arg1 = (wxMenu *) 0 ;
33399 size_t arg2 ;
33400 int arg3 ;
33401 wxString *arg4 = 0 ;
33402 wxMenu *arg5 = (wxMenu *) 0 ;
33403 wxString const &arg6_defvalue = wxPyEmptyString ;
33404 wxString *arg6 = (wxString *) &arg6_defvalue ;
33405 wxMenuItem *result;
33406 bool temp4 = false ;
33407 bool temp6 = false ;
33408 PyObject * obj0 = 0 ;
33409 PyObject * obj1 = 0 ;
33410 PyObject * obj2 = 0 ;
33411 PyObject * obj3 = 0 ;
33412 PyObject * obj4 = 0 ;
33413 PyObject * obj5 = 0 ;
33414 char *kwnames[] = {
33415 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33416 };
33417
33418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33420 if (SWIG_arg_fail(1)) SWIG_fail;
33421 {
33422 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33423 if (SWIG_arg_fail(2)) SWIG_fail;
33424 }
33425 {
33426 arg3 = (int)(SWIG_As_int(obj2));
33427 if (SWIG_arg_fail(3)) SWIG_fail;
33428 }
33429 {
33430 arg4 = wxString_in_helper(obj3);
33431 if (arg4 == NULL) SWIG_fail;
33432 temp4 = true;
33433 }
33434 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33435 if (SWIG_arg_fail(5)) SWIG_fail;
33436 if (obj5) {
33437 {
33438 arg6 = wxString_in_helper(obj5);
33439 if (arg6 == NULL) SWIG_fail;
33440 temp6 = true;
33441 }
33442 }
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33446
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 {
33451 resultobj = wxPyMake_wxObject(result, 0);
33452 }
33453 {
33454 if (temp4)
33455 delete arg4;
33456 }
33457 {
33458 if (temp6)
33459 delete arg6;
33460 }
33461 return resultobj;
33462 fail:
33463 {
33464 if (temp4)
33465 delete arg4;
33466 }
33467 {
33468 if (temp6)
33469 delete arg6;
33470 }
33471 return NULL;
33472 }
33473
33474
33475 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33476 PyObject *resultobj;
33477 wxMenu *arg1 = (wxMenu *) 0 ;
33478 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33479 wxMenuItem *result;
33480 PyObject * obj0 = 0 ;
33481 PyObject * obj1 = 0 ;
33482 char *kwnames[] = {
33483 (char *) "self",(char *) "item", NULL
33484 };
33485
33486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33488 if (SWIG_arg_fail(1)) SWIG_fail;
33489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33490 if (SWIG_arg_fail(2)) SWIG_fail;
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33494
33495 wxPyEndAllowThreads(__tstate);
33496 if (PyErr_Occurred()) SWIG_fail;
33497 }
33498 {
33499 resultobj = wxPyMake_wxObject(result, 0);
33500 }
33501 return resultobj;
33502 fail:
33503 return NULL;
33504 }
33505
33506
33507 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj;
33509 wxMenu *arg1 = (wxMenu *) 0 ;
33510 int arg2 ;
33511 wxString *arg3 = 0 ;
33512 wxString const &arg4_defvalue = wxPyEmptyString ;
33513 wxString *arg4 = (wxString *) &arg4_defvalue ;
33514 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33515 wxMenuItem *result;
33516 bool temp3 = false ;
33517 bool temp4 = false ;
33518 PyObject * obj0 = 0 ;
33519 PyObject * obj1 = 0 ;
33520 PyObject * obj2 = 0 ;
33521 PyObject * obj3 = 0 ;
33522 PyObject * obj4 = 0 ;
33523 char *kwnames[] = {
33524 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33525 };
33526
33527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33529 if (SWIG_arg_fail(1)) SWIG_fail;
33530 {
33531 arg2 = (int)(SWIG_As_int(obj1));
33532 if (SWIG_arg_fail(2)) SWIG_fail;
33533 }
33534 {
33535 arg3 = wxString_in_helper(obj2);
33536 if (arg3 == NULL) SWIG_fail;
33537 temp3 = true;
33538 }
33539 if (obj3) {
33540 {
33541 arg4 = wxString_in_helper(obj3);
33542 if (arg4 == NULL) SWIG_fail;
33543 temp4 = true;
33544 }
33545 }
33546 if (obj4) {
33547 {
33548 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33549 if (SWIG_arg_fail(5)) SWIG_fail;
33550 }
33551 }
33552 {
33553 PyThreadState* __tstate = wxPyBeginAllowThreads();
33554 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33555
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = wxPyMake_wxObject(result, 0);
33561 }
33562 {
33563 if (temp3)
33564 delete arg3;
33565 }
33566 {
33567 if (temp4)
33568 delete arg4;
33569 }
33570 return resultobj;
33571 fail:
33572 {
33573 if (temp3)
33574 delete arg3;
33575 }
33576 {
33577 if (temp4)
33578 delete arg4;
33579 }
33580 return NULL;
33581 }
33582
33583
33584 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33585 PyObject *resultobj;
33586 wxMenu *arg1 = (wxMenu *) 0 ;
33587 wxMenuItem *result;
33588 PyObject * obj0 = 0 ;
33589 char *kwnames[] = {
33590 (char *) "self", NULL
33591 };
33592
33593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33595 if (SWIG_arg_fail(1)) SWIG_fail;
33596 {
33597 PyThreadState* __tstate = wxPyBeginAllowThreads();
33598 result = (wxMenuItem *)(arg1)->PrependSeparator();
33599
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 {
33604 resultobj = wxPyMake_wxObject(result, 0);
33605 }
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj;
33614 wxMenu *arg1 = (wxMenu *) 0 ;
33615 int arg2 ;
33616 wxString *arg3 = 0 ;
33617 wxString const &arg4_defvalue = wxPyEmptyString ;
33618 wxString *arg4 = (wxString *) &arg4_defvalue ;
33619 wxMenuItem *result;
33620 bool temp3 = false ;
33621 bool temp4 = false ;
33622 PyObject * obj0 = 0 ;
33623 PyObject * obj1 = 0 ;
33624 PyObject * obj2 = 0 ;
33625 PyObject * obj3 = 0 ;
33626 char *kwnames[] = {
33627 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33628 };
33629
33630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33632 if (SWIG_arg_fail(1)) SWIG_fail;
33633 {
33634 arg2 = (int)(SWIG_As_int(obj1));
33635 if (SWIG_arg_fail(2)) SWIG_fail;
33636 }
33637 {
33638 arg3 = wxString_in_helper(obj2);
33639 if (arg3 == NULL) SWIG_fail;
33640 temp3 = true;
33641 }
33642 if (obj3) {
33643 {
33644 arg4 = wxString_in_helper(obj3);
33645 if (arg4 == NULL) SWIG_fail;
33646 temp4 = true;
33647 }
33648 }
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33652
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 {
33657 resultobj = wxPyMake_wxObject(result, 0);
33658 }
33659 {
33660 if (temp3)
33661 delete arg3;
33662 }
33663 {
33664 if (temp4)
33665 delete arg4;
33666 }
33667 return resultobj;
33668 fail:
33669 {
33670 if (temp3)
33671 delete arg3;
33672 }
33673 {
33674 if (temp4)
33675 delete arg4;
33676 }
33677 return NULL;
33678 }
33679
33680
33681 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj;
33683 wxMenu *arg1 = (wxMenu *) 0 ;
33684 int arg2 ;
33685 wxString *arg3 = 0 ;
33686 wxString const &arg4_defvalue = wxPyEmptyString ;
33687 wxString *arg4 = (wxString *) &arg4_defvalue ;
33688 wxMenuItem *result;
33689 bool temp3 = false ;
33690 bool temp4 = false ;
33691 PyObject * obj0 = 0 ;
33692 PyObject * obj1 = 0 ;
33693 PyObject * obj2 = 0 ;
33694 PyObject * obj3 = 0 ;
33695 char *kwnames[] = {
33696 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33697 };
33698
33699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33701 if (SWIG_arg_fail(1)) SWIG_fail;
33702 {
33703 arg2 = (int)(SWIG_As_int(obj1));
33704 if (SWIG_arg_fail(2)) SWIG_fail;
33705 }
33706 {
33707 arg3 = wxString_in_helper(obj2);
33708 if (arg3 == NULL) SWIG_fail;
33709 temp3 = true;
33710 }
33711 if (obj3) {
33712 {
33713 arg4 = wxString_in_helper(obj3);
33714 if (arg4 == NULL) SWIG_fail;
33715 temp4 = true;
33716 }
33717 }
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33721
33722 wxPyEndAllowThreads(__tstate);
33723 if (PyErr_Occurred()) SWIG_fail;
33724 }
33725 {
33726 resultobj = wxPyMake_wxObject(result, 0);
33727 }
33728 {
33729 if (temp3)
33730 delete arg3;
33731 }
33732 {
33733 if (temp4)
33734 delete arg4;
33735 }
33736 return resultobj;
33737 fail:
33738 {
33739 if (temp3)
33740 delete arg3;
33741 }
33742 {
33743 if (temp4)
33744 delete arg4;
33745 }
33746 return NULL;
33747 }
33748
33749
33750 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33751 PyObject *resultobj;
33752 wxMenu *arg1 = (wxMenu *) 0 ;
33753 int arg2 ;
33754 wxString *arg3 = 0 ;
33755 wxMenu *arg4 = (wxMenu *) 0 ;
33756 wxString const &arg5_defvalue = wxPyEmptyString ;
33757 wxString *arg5 = (wxString *) &arg5_defvalue ;
33758 wxMenuItem *result;
33759 bool temp3 = false ;
33760 bool temp5 = false ;
33761 PyObject * obj0 = 0 ;
33762 PyObject * obj1 = 0 ;
33763 PyObject * obj2 = 0 ;
33764 PyObject * obj3 = 0 ;
33765 PyObject * obj4 = 0 ;
33766 char *kwnames[] = {
33767 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33768 };
33769
33770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33772 if (SWIG_arg_fail(1)) SWIG_fail;
33773 {
33774 arg2 = (int)(SWIG_As_int(obj1));
33775 if (SWIG_arg_fail(2)) SWIG_fail;
33776 }
33777 {
33778 arg3 = wxString_in_helper(obj2);
33779 if (arg3 == NULL) SWIG_fail;
33780 temp3 = true;
33781 }
33782 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33783 if (SWIG_arg_fail(4)) SWIG_fail;
33784 if (obj4) {
33785 {
33786 arg5 = wxString_in_helper(obj4);
33787 if (arg5 == NULL) SWIG_fail;
33788 temp5 = true;
33789 }
33790 }
33791 {
33792 PyThreadState* __tstate = wxPyBeginAllowThreads();
33793 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33794
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 {
33799 resultobj = wxPyMake_wxObject(result, 0);
33800 }
33801 {
33802 if (temp3)
33803 delete arg3;
33804 }
33805 {
33806 if (temp5)
33807 delete arg5;
33808 }
33809 return resultobj;
33810 fail:
33811 {
33812 if (temp3)
33813 delete arg3;
33814 }
33815 {
33816 if (temp5)
33817 delete arg5;
33818 }
33819 return NULL;
33820 }
33821
33822
33823 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj;
33825 wxMenu *arg1 = (wxMenu *) 0 ;
33826 int arg2 ;
33827 wxMenuItem *result;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char *kwnames[] = {
33831 (char *) "self",(char *) "id", NULL
33832 };
33833
33834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33836 if (SWIG_arg_fail(1)) SWIG_fail;
33837 {
33838 arg2 = (int)(SWIG_As_int(obj1));
33839 if (SWIG_arg_fail(2)) SWIG_fail;
33840 }
33841 {
33842 PyThreadState* __tstate = wxPyBeginAllowThreads();
33843 result = (wxMenuItem *)(arg1)->Remove(arg2);
33844
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 {
33849 resultobj = wxPyMake_wxObject(result, 0);
33850 }
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj;
33859 wxMenu *arg1 = (wxMenu *) 0 ;
33860 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33861 wxMenuItem *result;
33862 PyObject * obj0 = 0 ;
33863 PyObject * obj1 = 0 ;
33864 char *kwnames[] = {
33865 (char *) "self",(char *) "item", NULL
33866 };
33867
33868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33870 if (SWIG_arg_fail(1)) SWIG_fail;
33871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33872 if (SWIG_arg_fail(2)) SWIG_fail;
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (wxMenuItem *)(arg1)->Remove(arg2);
33876
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 {
33881 resultobj = wxPyMake_wxObject(result, 0);
33882 }
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33890 PyObject *resultobj;
33891 wxMenu *arg1 = (wxMenu *) 0 ;
33892 int arg2 ;
33893 bool result;
33894 PyObject * obj0 = 0 ;
33895 PyObject * obj1 = 0 ;
33896 char *kwnames[] = {
33897 (char *) "self",(char *) "id", NULL
33898 };
33899
33900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33902 if (SWIG_arg_fail(1)) SWIG_fail;
33903 {
33904 arg2 = (int)(SWIG_As_int(obj1));
33905 if (SWIG_arg_fail(2)) SWIG_fail;
33906 }
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (bool)(arg1)->Delete(arg2);
33910
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 {
33915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33916 }
33917 return resultobj;
33918 fail:
33919 return NULL;
33920 }
33921
33922
33923 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33924 PyObject *resultobj;
33925 wxMenu *arg1 = (wxMenu *) 0 ;
33926 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33927 bool result;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 char *kwnames[] = {
33931 (char *) "self",(char *) "item", NULL
33932 };
33933
33934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33936 if (SWIG_arg_fail(1)) SWIG_fail;
33937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33938 if (SWIG_arg_fail(2)) SWIG_fail;
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 result = (bool)(arg1)->Delete(arg2);
33942
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 {
33947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33948 }
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33956 PyObject *resultobj;
33957 wxMenu *arg1 = (wxMenu *) 0 ;
33958 PyObject * obj0 = 0 ;
33959 char *kwnames[] = {
33960 (char *) "self", NULL
33961 };
33962
33963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33965 if (SWIG_arg_fail(1)) SWIG_fail;
33966 {
33967 PyThreadState* __tstate = wxPyBeginAllowThreads();
33968 wxMenu_Destroy(arg1);
33969
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 Py_INCREF(Py_None); resultobj = Py_None;
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj;
33982 wxMenu *arg1 = (wxMenu *) 0 ;
33983 int arg2 ;
33984 bool result;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char *kwnames[] = {
33988 (char *) "self",(char *) "id", NULL
33989 };
33990
33991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33993 if (SWIG_arg_fail(1)) SWIG_fail;
33994 {
33995 arg2 = (int)(SWIG_As_int(obj1));
33996 if (SWIG_arg_fail(2)) SWIG_fail;
33997 }
33998 {
33999 PyThreadState* __tstate = wxPyBeginAllowThreads();
34000 result = (bool)(arg1)->Destroy(arg2);
34001
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 {
34006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34007 }
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj;
34016 wxMenu *arg1 = (wxMenu *) 0 ;
34017 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34018 bool result;
34019 PyObject * obj0 = 0 ;
34020 PyObject * obj1 = 0 ;
34021 char *kwnames[] = {
34022 (char *) "self",(char *) "item", NULL
34023 };
34024
34025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34027 if (SWIG_arg_fail(1)) SWIG_fail;
34028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34029 if (SWIG_arg_fail(2)) SWIG_fail;
34030 {
34031 PyThreadState* __tstate = wxPyBeginAllowThreads();
34032 result = (bool)(arg1)->Destroy(arg2);
34033
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 {
34038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34039 }
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj;
34048 wxMenu *arg1 = (wxMenu *) 0 ;
34049 size_t result;
34050 PyObject * obj0 = 0 ;
34051 char *kwnames[] = {
34052 (char *) "self", NULL
34053 };
34054
34055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34057 if (SWIG_arg_fail(1)) SWIG_fail;
34058 {
34059 PyThreadState* __tstate = wxPyBeginAllowThreads();
34060 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34061
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 {
34066 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34067 }
34068 return resultobj;
34069 fail:
34070 return NULL;
34071 }
34072
34073
34074 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34075 PyObject *resultobj;
34076 wxMenu *arg1 = (wxMenu *) 0 ;
34077 PyObject *result;
34078 PyObject * obj0 = 0 ;
34079 char *kwnames[] = {
34080 (char *) "self", NULL
34081 };
34082
34083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34085 if (SWIG_arg_fail(1)) SWIG_fail;
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34089
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 resultobj = result;
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj;
34102 wxMenu *arg1 = (wxMenu *) 0 ;
34103 wxString *arg2 = 0 ;
34104 int result;
34105 bool temp2 = false ;
34106 PyObject * obj0 = 0 ;
34107 PyObject * obj1 = 0 ;
34108 char *kwnames[] = {
34109 (char *) "self",(char *) "item", NULL
34110 };
34111
34112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34114 if (SWIG_arg_fail(1)) SWIG_fail;
34115 {
34116 arg2 = wxString_in_helper(obj1);
34117 if (arg2 == NULL) SWIG_fail;
34118 temp2 = true;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 {
34128 resultobj = SWIG_From_int((int)(result));
34129 }
34130 {
34131 if (temp2)
34132 delete arg2;
34133 }
34134 return resultobj;
34135 fail:
34136 {
34137 if (temp2)
34138 delete arg2;
34139 }
34140 return NULL;
34141 }
34142
34143
34144 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj;
34146 wxMenu *arg1 = (wxMenu *) 0 ;
34147 int arg2 ;
34148 wxMenuItem *result;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 char *kwnames[] = {
34152 (char *) "self",(char *) "id", NULL
34153 };
34154
34155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34157 if (SWIG_arg_fail(1)) SWIG_fail;
34158 {
34159 arg2 = (int)(SWIG_As_int(obj1));
34160 if (SWIG_arg_fail(2)) SWIG_fail;
34161 }
34162 {
34163 PyThreadState* __tstate = wxPyBeginAllowThreads();
34164 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34165
34166 wxPyEndAllowThreads(__tstate);
34167 if (PyErr_Occurred()) SWIG_fail;
34168 }
34169 {
34170 resultobj = wxPyMake_wxObject(result, 0);
34171 }
34172 return resultobj;
34173 fail:
34174 return NULL;
34175 }
34176
34177
34178 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34179 PyObject *resultobj;
34180 wxMenu *arg1 = (wxMenu *) 0 ;
34181 size_t arg2 ;
34182 wxMenuItem *result;
34183 PyObject * obj0 = 0 ;
34184 PyObject * obj1 = 0 ;
34185 char *kwnames[] = {
34186 (char *) "self",(char *) "position", NULL
34187 };
34188
34189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34191 if (SWIG_arg_fail(1)) SWIG_fail;
34192 {
34193 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34194 if (SWIG_arg_fail(2)) SWIG_fail;
34195 }
34196 {
34197 PyThreadState* __tstate = wxPyBeginAllowThreads();
34198 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34199
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 {
34204 resultobj = wxPyMake_wxObject(result, 0);
34205 }
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34213 PyObject *resultobj;
34214 wxMenu *arg1 = (wxMenu *) 0 ;
34215 int arg2 ;
34216 bool arg3 ;
34217 PyObject * obj0 = 0 ;
34218 PyObject * obj1 = 0 ;
34219 PyObject * obj2 = 0 ;
34220 char *kwnames[] = {
34221 (char *) "self",(char *) "id",(char *) "enable", NULL
34222 };
34223
34224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34226 if (SWIG_arg_fail(1)) SWIG_fail;
34227 {
34228 arg2 = (int)(SWIG_As_int(obj1));
34229 if (SWIG_arg_fail(2)) SWIG_fail;
34230 }
34231 {
34232 arg3 = (bool)(SWIG_As_bool(obj2));
34233 if (SWIG_arg_fail(3)) SWIG_fail;
34234 }
34235 {
34236 PyThreadState* __tstate = wxPyBeginAllowThreads();
34237 (arg1)->Enable(arg2,arg3);
34238
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 Py_INCREF(Py_None); resultobj = Py_None;
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj;
34251 wxMenu *arg1 = (wxMenu *) 0 ;
34252 int arg2 ;
34253 bool result;
34254 PyObject * obj0 = 0 ;
34255 PyObject * obj1 = 0 ;
34256 char *kwnames[] = {
34257 (char *) "self",(char *) "id", NULL
34258 };
34259
34260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34262 if (SWIG_arg_fail(1)) SWIG_fail;
34263 {
34264 arg2 = (int)(SWIG_As_int(obj1));
34265 if (SWIG_arg_fail(2)) SWIG_fail;
34266 }
34267 {
34268 PyThreadState* __tstate = wxPyBeginAllowThreads();
34269 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34270
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 {
34275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34276 }
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34284 PyObject *resultobj;
34285 wxMenu *arg1 = (wxMenu *) 0 ;
34286 int arg2 ;
34287 bool arg3 ;
34288 PyObject * obj0 = 0 ;
34289 PyObject * obj1 = 0 ;
34290 PyObject * obj2 = 0 ;
34291 char *kwnames[] = {
34292 (char *) "self",(char *) "id",(char *) "check", NULL
34293 };
34294
34295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34297 if (SWIG_arg_fail(1)) SWIG_fail;
34298 {
34299 arg2 = (int)(SWIG_As_int(obj1));
34300 if (SWIG_arg_fail(2)) SWIG_fail;
34301 }
34302 {
34303 arg3 = (bool)(SWIG_As_bool(obj2));
34304 if (SWIG_arg_fail(3)) SWIG_fail;
34305 }
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 (arg1)->Check(arg2,arg3);
34309
34310 wxPyEndAllowThreads(__tstate);
34311 if (PyErr_Occurred()) SWIG_fail;
34312 }
34313 Py_INCREF(Py_None); resultobj = Py_None;
34314 return resultobj;
34315 fail:
34316 return NULL;
34317 }
34318
34319
34320 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34321 PyObject *resultobj;
34322 wxMenu *arg1 = (wxMenu *) 0 ;
34323 int arg2 ;
34324 bool result;
34325 PyObject * obj0 = 0 ;
34326 PyObject * obj1 = 0 ;
34327 char *kwnames[] = {
34328 (char *) "self",(char *) "id", NULL
34329 };
34330
34331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34333 if (SWIG_arg_fail(1)) SWIG_fail;
34334 {
34335 arg2 = (int)(SWIG_As_int(obj1));
34336 if (SWIG_arg_fail(2)) SWIG_fail;
34337 }
34338 {
34339 PyThreadState* __tstate = wxPyBeginAllowThreads();
34340 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34341
34342 wxPyEndAllowThreads(__tstate);
34343 if (PyErr_Occurred()) SWIG_fail;
34344 }
34345 {
34346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34347 }
34348 return resultobj;
34349 fail:
34350 return NULL;
34351 }
34352
34353
34354 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34355 PyObject *resultobj;
34356 wxMenu *arg1 = (wxMenu *) 0 ;
34357 int arg2 ;
34358 wxString *arg3 = 0 ;
34359 bool temp3 = false ;
34360 PyObject * obj0 = 0 ;
34361 PyObject * obj1 = 0 ;
34362 PyObject * obj2 = 0 ;
34363 char *kwnames[] = {
34364 (char *) "self",(char *) "id",(char *) "label", NULL
34365 };
34366
34367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34369 if (SWIG_arg_fail(1)) SWIG_fail;
34370 {
34371 arg2 = (int)(SWIG_As_int(obj1));
34372 if (SWIG_arg_fail(2)) SWIG_fail;
34373 }
34374 {
34375 arg3 = wxString_in_helper(obj2);
34376 if (arg3 == NULL) SWIG_fail;
34377 temp3 = true;
34378 }
34379 {
34380 PyThreadState* __tstate = wxPyBeginAllowThreads();
34381 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34382
34383 wxPyEndAllowThreads(__tstate);
34384 if (PyErr_Occurred()) SWIG_fail;
34385 }
34386 Py_INCREF(Py_None); resultobj = Py_None;
34387 {
34388 if (temp3)
34389 delete arg3;
34390 }
34391 return resultobj;
34392 fail:
34393 {
34394 if (temp3)
34395 delete arg3;
34396 }
34397 return NULL;
34398 }
34399
34400
34401 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34402 PyObject *resultobj;
34403 wxMenu *arg1 = (wxMenu *) 0 ;
34404 int arg2 ;
34405 wxString result;
34406 PyObject * obj0 = 0 ;
34407 PyObject * obj1 = 0 ;
34408 char *kwnames[] = {
34409 (char *) "self",(char *) "id", NULL
34410 };
34411
34412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34414 if (SWIG_arg_fail(1)) SWIG_fail;
34415 {
34416 arg2 = (int)(SWIG_As_int(obj1));
34417 if (SWIG_arg_fail(2)) SWIG_fail;
34418 }
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34422
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 {
34427 #if wxUSE_UNICODE
34428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34429 #else
34430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34431 #endif
34432 }
34433 return resultobj;
34434 fail:
34435 return NULL;
34436 }
34437
34438
34439 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34440 PyObject *resultobj;
34441 wxMenu *arg1 = (wxMenu *) 0 ;
34442 int arg2 ;
34443 wxString *arg3 = 0 ;
34444 bool temp3 = false ;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 PyObject * obj2 = 0 ;
34448 char *kwnames[] = {
34449 (char *) "self",(char *) "id",(char *) "helpString", NULL
34450 };
34451
34452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34454 if (SWIG_arg_fail(1)) SWIG_fail;
34455 {
34456 arg2 = (int)(SWIG_As_int(obj1));
34457 if (SWIG_arg_fail(2)) SWIG_fail;
34458 }
34459 {
34460 arg3 = wxString_in_helper(obj2);
34461 if (arg3 == NULL) SWIG_fail;
34462 temp3 = true;
34463 }
34464 {
34465 PyThreadState* __tstate = wxPyBeginAllowThreads();
34466 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34467
34468 wxPyEndAllowThreads(__tstate);
34469 if (PyErr_Occurred()) SWIG_fail;
34470 }
34471 Py_INCREF(Py_None); resultobj = Py_None;
34472 {
34473 if (temp3)
34474 delete arg3;
34475 }
34476 return resultobj;
34477 fail:
34478 {
34479 if (temp3)
34480 delete arg3;
34481 }
34482 return NULL;
34483 }
34484
34485
34486 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34487 PyObject *resultobj;
34488 wxMenu *arg1 = (wxMenu *) 0 ;
34489 int arg2 ;
34490 wxString result;
34491 PyObject * obj0 = 0 ;
34492 PyObject * obj1 = 0 ;
34493 char *kwnames[] = {
34494 (char *) "self",(char *) "id", NULL
34495 };
34496
34497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34499 if (SWIG_arg_fail(1)) SWIG_fail;
34500 {
34501 arg2 = (int)(SWIG_As_int(obj1));
34502 if (SWIG_arg_fail(2)) SWIG_fail;
34503 }
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34507
34508 wxPyEndAllowThreads(__tstate);
34509 if (PyErr_Occurred()) SWIG_fail;
34510 }
34511 {
34512 #if wxUSE_UNICODE
34513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34514 #else
34515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34516 #endif
34517 }
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34525 PyObject *resultobj;
34526 wxMenu *arg1 = (wxMenu *) 0 ;
34527 wxString *arg2 = 0 ;
34528 bool temp2 = false ;
34529 PyObject * obj0 = 0 ;
34530 PyObject * obj1 = 0 ;
34531 char *kwnames[] = {
34532 (char *) "self",(char *) "title", NULL
34533 };
34534
34535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34537 if (SWIG_arg_fail(1)) SWIG_fail;
34538 {
34539 arg2 = wxString_in_helper(obj1);
34540 if (arg2 == NULL) SWIG_fail;
34541 temp2 = true;
34542 }
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 (arg1)->SetTitle((wxString const &)*arg2);
34546
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 Py_INCREF(Py_None); resultobj = Py_None;
34551 {
34552 if (temp2)
34553 delete arg2;
34554 }
34555 return resultobj;
34556 fail:
34557 {
34558 if (temp2)
34559 delete arg2;
34560 }
34561 return NULL;
34562 }
34563
34564
34565 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34566 PyObject *resultobj;
34567 wxMenu *arg1 = (wxMenu *) 0 ;
34568 wxString result;
34569 PyObject * obj0 = 0 ;
34570 char *kwnames[] = {
34571 (char *) "self", NULL
34572 };
34573
34574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34576 if (SWIG_arg_fail(1)) SWIG_fail;
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 result = ((wxMenu const *)arg1)->GetTitle();
34580
34581 wxPyEndAllowThreads(__tstate);
34582 if (PyErr_Occurred()) SWIG_fail;
34583 }
34584 {
34585 #if wxUSE_UNICODE
34586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34587 #else
34588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34589 #endif
34590 }
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj;
34599 wxMenu *arg1 = (wxMenu *) 0 ;
34600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34601 PyObject * obj0 = 0 ;
34602 PyObject * obj1 = 0 ;
34603 char *kwnames[] = {
34604 (char *) "self",(char *) "handler", NULL
34605 };
34606
34607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34609 if (SWIG_arg_fail(1)) SWIG_fail;
34610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34611 if (SWIG_arg_fail(2)) SWIG_fail;
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 (arg1)->SetEventHandler(arg2);
34615
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 Py_INCREF(Py_None); resultobj = Py_None;
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj;
34628 wxMenu *arg1 = (wxMenu *) 0 ;
34629 wxEvtHandler *result;
34630 PyObject * obj0 = 0 ;
34631 char *kwnames[] = {
34632 (char *) "self", NULL
34633 };
34634
34635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34637 if (SWIG_arg_fail(1)) SWIG_fail;
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34641
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 {
34646 resultobj = wxPyMake_wxObject(result, 0);
34647 }
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34655 PyObject *resultobj;
34656 wxMenu *arg1 = (wxMenu *) 0 ;
34657 wxWindow *arg2 = (wxWindow *) 0 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 char *kwnames[] = {
34661 (char *) "self",(char *) "win", NULL
34662 };
34663
34664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34666 if (SWIG_arg_fail(1)) SWIG_fail;
34667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34668 if (SWIG_arg_fail(2)) SWIG_fail;
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 (arg1)->SetInvokingWindow(arg2);
34672
34673 wxPyEndAllowThreads(__tstate);
34674 if (PyErr_Occurred()) SWIG_fail;
34675 }
34676 Py_INCREF(Py_None); resultobj = Py_None;
34677 return resultobj;
34678 fail:
34679 return NULL;
34680 }
34681
34682
34683 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34684 PyObject *resultobj;
34685 wxMenu *arg1 = (wxMenu *) 0 ;
34686 wxWindow *result;
34687 PyObject * obj0 = 0 ;
34688 char *kwnames[] = {
34689 (char *) "self", NULL
34690 };
34691
34692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34694 if (SWIG_arg_fail(1)) SWIG_fail;
34695 {
34696 PyThreadState* __tstate = wxPyBeginAllowThreads();
34697 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34698
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = wxPyMake_wxObject(result, 0);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj;
34713 wxMenu *arg1 = (wxMenu *) 0 ;
34714 long result;
34715 PyObject * obj0 = 0 ;
34716 char *kwnames[] = {
34717 (char *) "self", NULL
34718 };
34719
34720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34722 if (SWIG_arg_fail(1)) SWIG_fail;
34723 {
34724 PyThreadState* __tstate = wxPyBeginAllowThreads();
34725 result = (long)((wxMenu const *)arg1)->GetStyle();
34726
34727 wxPyEndAllowThreads(__tstate);
34728 if (PyErr_Occurred()) SWIG_fail;
34729 }
34730 {
34731 resultobj = SWIG_From_long((long)(result));
34732 }
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34740 PyObject *resultobj;
34741 wxMenu *arg1 = (wxMenu *) 0 ;
34742 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34743 PyObject * obj0 = 0 ;
34744 PyObject * obj1 = 0 ;
34745 char *kwnames[] = {
34746 (char *) "self",(char *) "source", NULL
34747 };
34748
34749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34751 if (SWIG_arg_fail(1)) SWIG_fail;
34752 if (obj1) {
34753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34754 if (SWIG_arg_fail(2)) SWIG_fail;
34755 }
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 (arg1)->UpdateUI(arg2);
34759
34760 wxPyEndAllowThreads(__tstate);
34761 if (PyErr_Occurred()) SWIG_fail;
34762 }
34763 Py_INCREF(Py_None); resultobj = Py_None;
34764 return resultobj;
34765 fail:
34766 return NULL;
34767 }
34768
34769
34770 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34771 PyObject *resultobj;
34772 wxMenu *arg1 = (wxMenu *) 0 ;
34773 wxMenuBar *result;
34774 PyObject * obj0 = 0 ;
34775 char *kwnames[] = {
34776 (char *) "self", NULL
34777 };
34778
34779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34781 if (SWIG_arg_fail(1)) SWIG_fail;
34782 {
34783 PyThreadState* __tstate = wxPyBeginAllowThreads();
34784 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34785
34786 wxPyEndAllowThreads(__tstate);
34787 if (PyErr_Occurred()) SWIG_fail;
34788 }
34789 {
34790 resultobj = wxPyMake_wxObject(result, 0);
34791 }
34792 return resultobj;
34793 fail:
34794 return NULL;
34795 }
34796
34797
34798 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34799 PyObject *resultobj;
34800 wxMenu *arg1 = (wxMenu *) 0 ;
34801 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34802 PyObject * obj0 = 0 ;
34803 PyObject * obj1 = 0 ;
34804 char *kwnames[] = {
34805 (char *) "self",(char *) "menubar", NULL
34806 };
34807
34808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(1)) SWIG_fail;
34811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34812 if (SWIG_arg_fail(2)) SWIG_fail;
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 (arg1)->Attach(arg2);
34816
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 Py_INCREF(Py_None); resultobj = Py_None;
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34828 PyObject *resultobj;
34829 wxMenu *arg1 = (wxMenu *) 0 ;
34830 PyObject * obj0 = 0 ;
34831 char *kwnames[] = {
34832 (char *) "self", NULL
34833 };
34834
34835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(1)) SWIG_fail;
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 (arg1)->Detach();
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 Py_INCREF(Py_None); resultobj = Py_None;
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj;
34854 wxMenu *arg1 = (wxMenu *) 0 ;
34855 bool result;
34856 PyObject * obj0 = 0 ;
34857 char *kwnames[] = {
34858 (char *) "self", NULL
34859 };
34860
34861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34863 if (SWIG_arg_fail(1)) SWIG_fail;
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (bool)((wxMenu const *)arg1)->IsAttached();
34867
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34881 PyObject *resultobj;
34882 wxMenu *arg1 = (wxMenu *) 0 ;
34883 wxMenu *arg2 = (wxMenu *) 0 ;
34884 PyObject * obj0 = 0 ;
34885 PyObject * obj1 = 0 ;
34886 char *kwnames[] = {
34887 (char *) "self",(char *) "parent", NULL
34888 };
34889
34890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34892 if (SWIG_arg_fail(1)) SWIG_fail;
34893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34894 if (SWIG_arg_fail(2)) SWIG_fail;
34895 {
34896 PyThreadState* __tstate = wxPyBeginAllowThreads();
34897 (arg1)->SetParent(arg2);
34898
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 Py_INCREF(Py_None); resultobj = Py_None;
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj;
34911 wxMenu *arg1 = (wxMenu *) 0 ;
34912 wxMenu *result;
34913 PyObject * obj0 = 0 ;
34914 char *kwnames[] = {
34915 (char *) "self", NULL
34916 };
34917
34918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34920 if (SWIG_arg_fail(1)) SWIG_fail;
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34924
34925 wxPyEndAllowThreads(__tstate);
34926 if (PyErr_Occurred()) SWIG_fail;
34927 }
34928 {
34929 resultobj = wxPyMake_wxObject(result, 0);
34930 }
34931 return resultobj;
34932 fail:
34933 return NULL;
34934 }
34935
34936
34937 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34938 PyObject *obj;
34939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34940 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34941 Py_INCREF(obj);
34942 return Py_BuildValue((char *)"");
34943 }
34944 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34945 PyObject *resultobj;
34946 long arg1 = (long) 0 ;
34947 wxMenuBar *result;
34948 PyObject * obj0 = 0 ;
34949 char *kwnames[] = {
34950 (char *) "style", NULL
34951 };
34952
34953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34954 if (obj0) {
34955 {
34956 arg1 = (long)(SWIG_As_long(obj0));
34957 if (SWIG_arg_fail(1)) SWIG_fail;
34958 }
34959 }
34960 {
34961 if (!wxPyCheckForApp()) SWIG_fail;
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 result = (wxMenuBar *)new wxMenuBar(arg1);
34964
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj;
34977 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34978 wxMenu *arg2 = (wxMenu *) 0 ;
34979 wxString *arg3 = 0 ;
34980 bool result;
34981 bool temp3 = false ;
34982 PyObject * obj0 = 0 ;
34983 PyObject * obj1 = 0 ;
34984 PyObject * obj2 = 0 ;
34985 char *kwnames[] = {
34986 (char *) "self",(char *) "menu",(char *) "title", NULL
34987 };
34988
34989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34991 if (SWIG_arg_fail(1)) SWIG_fail;
34992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34993 if (SWIG_arg_fail(2)) SWIG_fail;
34994 {
34995 arg3 = wxString_in_helper(obj2);
34996 if (arg3 == NULL) SWIG_fail;
34997 temp3 = true;
34998 }
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35002
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 {
35007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35008 }
35009 {
35010 if (temp3)
35011 delete arg3;
35012 }
35013 return resultobj;
35014 fail:
35015 {
35016 if (temp3)
35017 delete arg3;
35018 }
35019 return NULL;
35020 }
35021
35022
35023 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35024 PyObject *resultobj;
35025 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35026 size_t arg2 ;
35027 wxMenu *arg3 = (wxMenu *) 0 ;
35028 wxString *arg4 = 0 ;
35029 bool result;
35030 bool temp4 = false ;
35031 PyObject * obj0 = 0 ;
35032 PyObject * obj1 = 0 ;
35033 PyObject * obj2 = 0 ;
35034 PyObject * obj3 = 0 ;
35035 char *kwnames[] = {
35036 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35037 };
35038
35039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35041 if (SWIG_arg_fail(1)) SWIG_fail;
35042 {
35043 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35044 if (SWIG_arg_fail(2)) SWIG_fail;
35045 }
35046 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35047 if (SWIG_arg_fail(3)) SWIG_fail;
35048 {
35049 arg4 = wxString_in_helper(obj3);
35050 if (arg4 == NULL) SWIG_fail;
35051 temp4 = true;
35052 }
35053 {
35054 PyThreadState* __tstate = wxPyBeginAllowThreads();
35055 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35056
35057 wxPyEndAllowThreads(__tstate);
35058 if (PyErr_Occurred()) SWIG_fail;
35059 }
35060 {
35061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35062 }
35063 {
35064 if (temp4)
35065 delete arg4;
35066 }
35067 return resultobj;
35068 fail:
35069 {
35070 if (temp4)
35071 delete arg4;
35072 }
35073 return NULL;
35074 }
35075
35076
35077 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35078 PyObject *resultobj;
35079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35080 size_t result;
35081 PyObject * obj0 = 0 ;
35082 char *kwnames[] = {
35083 (char *) "self", NULL
35084 };
35085
35086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35088 if (SWIG_arg_fail(1)) SWIG_fail;
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35092
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 {
35097 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35098 }
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35106 PyObject *resultobj;
35107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35108 size_t arg2 ;
35109 wxMenu *result;
35110 PyObject * obj0 = 0 ;
35111 PyObject * obj1 = 0 ;
35112 char *kwnames[] = {
35113 (char *) "self",(char *) "pos", NULL
35114 };
35115
35116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35118 if (SWIG_arg_fail(1)) SWIG_fail;
35119 {
35120 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35121 if (SWIG_arg_fail(2)) SWIG_fail;
35122 }
35123 {
35124 PyThreadState* __tstate = wxPyBeginAllowThreads();
35125 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35126
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 {
35131 resultobj = wxPyMake_wxObject(result, 0);
35132 }
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35140 PyObject *resultobj;
35141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35142 size_t arg2 ;
35143 wxMenu *arg3 = (wxMenu *) 0 ;
35144 wxString *arg4 = 0 ;
35145 wxMenu *result;
35146 bool temp4 = false ;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 PyObject * obj2 = 0 ;
35150 PyObject * obj3 = 0 ;
35151 char *kwnames[] = {
35152 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35153 };
35154
35155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35157 if (SWIG_arg_fail(1)) SWIG_fail;
35158 {
35159 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35160 if (SWIG_arg_fail(2)) SWIG_fail;
35161 }
35162 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35163 if (SWIG_arg_fail(3)) SWIG_fail;
35164 {
35165 arg4 = wxString_in_helper(obj3);
35166 if (arg4 == NULL) SWIG_fail;
35167 temp4 = true;
35168 }
35169 {
35170 PyThreadState* __tstate = wxPyBeginAllowThreads();
35171 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35172
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 {
35177 resultobj = wxPyMake_wxObject(result, 0);
35178 }
35179 {
35180 if (temp4)
35181 delete arg4;
35182 }
35183 return resultobj;
35184 fail:
35185 {
35186 if (temp4)
35187 delete arg4;
35188 }
35189 return NULL;
35190 }
35191
35192
35193 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj;
35195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35196 size_t arg2 ;
35197 wxMenu *result;
35198 PyObject * obj0 = 0 ;
35199 PyObject * obj1 = 0 ;
35200 char *kwnames[] = {
35201 (char *) "self",(char *) "pos", NULL
35202 };
35203
35204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35206 if (SWIG_arg_fail(1)) SWIG_fail;
35207 {
35208 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35209 if (SWIG_arg_fail(2)) SWIG_fail;
35210 }
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (wxMenu *)(arg1)->Remove(arg2);
35214
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 resultobj = wxPyMake_wxObject(result, 0);
35220 }
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj;
35229 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35230 size_t arg2 ;
35231 bool arg3 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 PyObject * obj2 = 0 ;
35235 char *kwnames[] = {
35236 (char *) "self",(char *) "pos",(char *) "enable", NULL
35237 };
35238
35239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35241 if (SWIG_arg_fail(1)) SWIG_fail;
35242 {
35243 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35244 if (SWIG_arg_fail(2)) SWIG_fail;
35245 }
35246 {
35247 arg3 = (bool)(SWIG_As_bool(obj2));
35248 if (SWIG_arg_fail(3)) SWIG_fail;
35249 }
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 (arg1)->EnableTop(arg2,arg3);
35253
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 Py_INCREF(Py_None); resultobj = Py_None;
35258 return resultobj;
35259 fail:
35260 return NULL;
35261 }
35262
35263
35264 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35265 PyObject *resultobj;
35266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35267 size_t arg2 ;
35268 bool result;
35269 PyObject * obj0 = 0 ;
35270 PyObject * obj1 = 0 ;
35271 char *kwnames[] = {
35272 (char *) "self",(char *) "pos", NULL
35273 };
35274
35275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35277 if (SWIG_arg_fail(1)) SWIG_fail;
35278 {
35279 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35280 if (SWIG_arg_fail(2)) SWIG_fail;
35281 }
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35285
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 {
35290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj;
35300 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35301 size_t arg2 ;
35302 wxString *arg3 = 0 ;
35303 bool temp3 = false ;
35304 PyObject * obj0 = 0 ;
35305 PyObject * obj1 = 0 ;
35306 PyObject * obj2 = 0 ;
35307 char *kwnames[] = {
35308 (char *) "self",(char *) "pos",(char *) "label", NULL
35309 };
35310
35311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35313 if (SWIG_arg_fail(1)) SWIG_fail;
35314 {
35315 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35316 if (SWIG_arg_fail(2)) SWIG_fail;
35317 }
35318 {
35319 arg3 = wxString_in_helper(obj2);
35320 if (arg3 == NULL) SWIG_fail;
35321 temp3 = true;
35322 }
35323 {
35324 PyThreadState* __tstate = wxPyBeginAllowThreads();
35325 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35326
35327 wxPyEndAllowThreads(__tstate);
35328 if (PyErr_Occurred()) SWIG_fail;
35329 }
35330 Py_INCREF(Py_None); resultobj = Py_None;
35331 {
35332 if (temp3)
35333 delete arg3;
35334 }
35335 return resultobj;
35336 fail:
35337 {
35338 if (temp3)
35339 delete arg3;
35340 }
35341 return NULL;
35342 }
35343
35344
35345 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35346 PyObject *resultobj;
35347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35348 size_t arg2 ;
35349 wxString result;
35350 PyObject * obj0 = 0 ;
35351 PyObject * obj1 = 0 ;
35352 char *kwnames[] = {
35353 (char *) "self",(char *) "pos", NULL
35354 };
35355
35356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35358 if (SWIG_arg_fail(1)) SWIG_fail;
35359 {
35360 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35361 if (SWIG_arg_fail(2)) SWIG_fail;
35362 }
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35366
35367 wxPyEndAllowThreads(__tstate);
35368 if (PyErr_Occurred()) SWIG_fail;
35369 }
35370 {
35371 #if wxUSE_UNICODE
35372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35373 #else
35374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35375 #endif
35376 }
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35384 PyObject *resultobj;
35385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35386 wxString *arg2 = 0 ;
35387 wxString *arg3 = 0 ;
35388 int result;
35389 bool temp2 = false ;
35390 bool temp3 = false ;
35391 PyObject * obj0 = 0 ;
35392 PyObject * obj1 = 0 ;
35393 PyObject * obj2 = 0 ;
35394 char *kwnames[] = {
35395 (char *) "self",(char *) "menu",(char *) "item", NULL
35396 };
35397
35398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35400 if (SWIG_arg_fail(1)) SWIG_fail;
35401 {
35402 arg2 = wxString_in_helper(obj1);
35403 if (arg2 == NULL) SWIG_fail;
35404 temp2 = true;
35405 }
35406 {
35407 arg3 = wxString_in_helper(obj2);
35408 if (arg3 == NULL) SWIG_fail;
35409 temp3 = true;
35410 }
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35414
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 {
35419 resultobj = SWIG_From_int((int)(result));
35420 }
35421 {
35422 if (temp2)
35423 delete arg2;
35424 }
35425 {
35426 if (temp3)
35427 delete arg3;
35428 }
35429 return resultobj;
35430 fail:
35431 {
35432 if (temp2)
35433 delete arg2;
35434 }
35435 {
35436 if (temp3)
35437 delete arg3;
35438 }
35439 return NULL;
35440 }
35441
35442
35443 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35444 PyObject *resultobj;
35445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35446 int arg2 ;
35447 wxMenuItem *result;
35448 PyObject * obj0 = 0 ;
35449 PyObject * obj1 = 0 ;
35450 char *kwnames[] = {
35451 (char *) "self",(char *) "id", NULL
35452 };
35453
35454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35456 if (SWIG_arg_fail(1)) SWIG_fail;
35457 {
35458 arg2 = (int)(SWIG_As_int(obj1));
35459 if (SWIG_arg_fail(2)) SWIG_fail;
35460 }
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35464
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 {
35469 resultobj = wxPyMake_wxObject(result, 0);
35470 }
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35478 PyObject *resultobj;
35479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35480 wxString *arg2 = 0 ;
35481 int result;
35482 bool temp2 = false ;
35483 PyObject * obj0 = 0 ;
35484 PyObject * obj1 = 0 ;
35485 char *kwnames[] = {
35486 (char *) "self",(char *) "title", NULL
35487 };
35488
35489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35491 if (SWIG_arg_fail(1)) SWIG_fail;
35492 {
35493 arg2 = wxString_in_helper(obj1);
35494 if (arg2 == NULL) SWIG_fail;
35495 temp2 = true;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 resultobj = SWIG_From_int((int)(result));
35506 }
35507 {
35508 if (temp2)
35509 delete arg2;
35510 }
35511 return resultobj;
35512 fail:
35513 {
35514 if (temp2)
35515 delete arg2;
35516 }
35517 return NULL;
35518 }
35519
35520
35521 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj;
35523 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35524 int arg2 ;
35525 bool arg3 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 PyObject * obj2 = 0 ;
35529 char *kwnames[] = {
35530 (char *) "self",(char *) "id",(char *) "enable", NULL
35531 };
35532
35533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35535 if (SWIG_arg_fail(1)) SWIG_fail;
35536 {
35537 arg2 = (int)(SWIG_As_int(obj1));
35538 if (SWIG_arg_fail(2)) SWIG_fail;
35539 }
35540 {
35541 arg3 = (bool)(SWIG_As_bool(obj2));
35542 if (SWIG_arg_fail(3)) SWIG_fail;
35543 }
35544 {
35545 PyThreadState* __tstate = wxPyBeginAllowThreads();
35546 (arg1)->Enable(arg2,arg3);
35547
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 Py_INCREF(Py_None); resultobj = Py_None;
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj;
35560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35561 int arg2 ;
35562 bool arg3 ;
35563 PyObject * obj0 = 0 ;
35564 PyObject * obj1 = 0 ;
35565 PyObject * obj2 = 0 ;
35566 char *kwnames[] = {
35567 (char *) "self",(char *) "id",(char *) "check", NULL
35568 };
35569
35570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35572 if (SWIG_arg_fail(1)) SWIG_fail;
35573 {
35574 arg2 = (int)(SWIG_As_int(obj1));
35575 if (SWIG_arg_fail(2)) SWIG_fail;
35576 }
35577 {
35578 arg3 = (bool)(SWIG_As_bool(obj2));
35579 if (SWIG_arg_fail(3)) SWIG_fail;
35580 }
35581 {
35582 PyThreadState* __tstate = wxPyBeginAllowThreads();
35583 (arg1)->Check(arg2,arg3);
35584
35585 wxPyEndAllowThreads(__tstate);
35586 if (PyErr_Occurred()) SWIG_fail;
35587 }
35588 Py_INCREF(Py_None); resultobj = Py_None;
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35596 PyObject *resultobj;
35597 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35598 int arg2 ;
35599 bool result;
35600 PyObject * obj0 = 0 ;
35601 PyObject * obj1 = 0 ;
35602 char *kwnames[] = {
35603 (char *) "self",(char *) "id", NULL
35604 };
35605
35606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35608 if (SWIG_arg_fail(1)) SWIG_fail;
35609 {
35610 arg2 = (int)(SWIG_As_int(obj1));
35611 if (SWIG_arg_fail(2)) SWIG_fail;
35612 }
35613 {
35614 PyThreadState* __tstate = wxPyBeginAllowThreads();
35615 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35616
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35622 }
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35630 PyObject *resultobj;
35631 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35632 int arg2 ;
35633 bool result;
35634 PyObject * obj0 = 0 ;
35635 PyObject * obj1 = 0 ;
35636 char *kwnames[] = {
35637 (char *) "self",(char *) "id", NULL
35638 };
35639
35640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35642 if (SWIG_arg_fail(1)) SWIG_fail;
35643 {
35644 arg2 = (int)(SWIG_As_int(obj1));
35645 if (SWIG_arg_fail(2)) SWIG_fail;
35646 }
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35650
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 {
35655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35656 }
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35664 PyObject *resultobj;
35665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35666 int arg2 ;
35667 wxString *arg3 = 0 ;
35668 bool temp3 = false ;
35669 PyObject * obj0 = 0 ;
35670 PyObject * obj1 = 0 ;
35671 PyObject * obj2 = 0 ;
35672 char *kwnames[] = {
35673 (char *) "self",(char *) "id",(char *) "label", NULL
35674 };
35675
35676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35678 if (SWIG_arg_fail(1)) SWIG_fail;
35679 {
35680 arg2 = (int)(SWIG_As_int(obj1));
35681 if (SWIG_arg_fail(2)) SWIG_fail;
35682 }
35683 {
35684 arg3 = wxString_in_helper(obj2);
35685 if (arg3 == NULL) SWIG_fail;
35686 temp3 = true;
35687 }
35688 {
35689 PyThreadState* __tstate = wxPyBeginAllowThreads();
35690 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35691
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 Py_INCREF(Py_None); resultobj = Py_None;
35696 {
35697 if (temp3)
35698 delete arg3;
35699 }
35700 return resultobj;
35701 fail:
35702 {
35703 if (temp3)
35704 delete arg3;
35705 }
35706 return NULL;
35707 }
35708
35709
35710 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35711 PyObject *resultobj;
35712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35713 int arg2 ;
35714 wxString result;
35715 PyObject * obj0 = 0 ;
35716 PyObject * obj1 = 0 ;
35717 char *kwnames[] = {
35718 (char *) "self",(char *) "id", NULL
35719 };
35720
35721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35723 if (SWIG_arg_fail(1)) SWIG_fail;
35724 {
35725 arg2 = (int)(SWIG_As_int(obj1));
35726 if (SWIG_arg_fail(2)) SWIG_fail;
35727 }
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35731
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 {
35736 #if wxUSE_UNICODE
35737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35738 #else
35739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35740 #endif
35741 }
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35749 PyObject *resultobj;
35750 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35751 int arg2 ;
35752 wxString *arg3 = 0 ;
35753 bool temp3 = false ;
35754 PyObject * obj0 = 0 ;
35755 PyObject * obj1 = 0 ;
35756 PyObject * obj2 = 0 ;
35757 char *kwnames[] = {
35758 (char *) "self",(char *) "id",(char *) "helpString", NULL
35759 };
35760
35761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35763 if (SWIG_arg_fail(1)) SWIG_fail;
35764 {
35765 arg2 = (int)(SWIG_As_int(obj1));
35766 if (SWIG_arg_fail(2)) SWIG_fail;
35767 }
35768 {
35769 arg3 = wxString_in_helper(obj2);
35770 if (arg3 == NULL) SWIG_fail;
35771 temp3 = true;
35772 }
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35776
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 Py_INCREF(Py_None); resultobj = Py_None;
35781 {
35782 if (temp3)
35783 delete arg3;
35784 }
35785 return resultobj;
35786 fail:
35787 {
35788 if (temp3)
35789 delete arg3;
35790 }
35791 return NULL;
35792 }
35793
35794
35795 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35796 PyObject *resultobj;
35797 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35798 int arg2 ;
35799 wxString result;
35800 PyObject * obj0 = 0 ;
35801 PyObject * obj1 = 0 ;
35802 char *kwnames[] = {
35803 (char *) "self",(char *) "id", NULL
35804 };
35805
35806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35808 if (SWIG_arg_fail(1)) SWIG_fail;
35809 {
35810 arg2 = (int)(SWIG_As_int(obj1));
35811 if (SWIG_arg_fail(2)) SWIG_fail;
35812 }
35813 {
35814 PyThreadState* __tstate = wxPyBeginAllowThreads();
35815 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35816
35817 wxPyEndAllowThreads(__tstate);
35818 if (PyErr_Occurred()) SWIG_fail;
35819 }
35820 {
35821 #if wxUSE_UNICODE
35822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35823 #else
35824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35825 #endif
35826 }
35827 return resultobj;
35828 fail:
35829 return NULL;
35830 }
35831
35832
35833 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35834 PyObject *resultobj;
35835 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35836 wxFrame *result;
35837 PyObject * obj0 = 0 ;
35838 char *kwnames[] = {
35839 (char *) "self", NULL
35840 };
35841
35842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35844 if (SWIG_arg_fail(1)) SWIG_fail;
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35848
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 {
35853 resultobj = wxPyMake_wxObject(result, 0);
35854 }
35855 return resultobj;
35856 fail:
35857 return NULL;
35858 }
35859
35860
35861 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35862 PyObject *resultobj;
35863 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35864 bool result;
35865 PyObject * obj0 = 0 ;
35866 char *kwnames[] = {
35867 (char *) "self", NULL
35868 };
35869
35870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35872 if (SWIG_arg_fail(1)) SWIG_fail;
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35876
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 {
35881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35882 }
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35890 PyObject *resultobj;
35891 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35892 wxFrame *arg2 = (wxFrame *) 0 ;
35893 PyObject * obj0 = 0 ;
35894 PyObject * obj1 = 0 ;
35895 char *kwnames[] = {
35896 (char *) "self",(char *) "frame", NULL
35897 };
35898
35899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35901 if (SWIG_arg_fail(1)) SWIG_fail;
35902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35903 if (SWIG_arg_fail(2)) SWIG_fail;
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 (arg1)->Attach(arg2);
35907
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 Py_INCREF(Py_None); resultobj = Py_None;
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj;
35920 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35921 PyObject * obj0 = 0 ;
35922 char *kwnames[] = {
35923 (char *) "self", NULL
35924 };
35925
35926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35928 if (SWIG_arg_fail(1)) SWIG_fail;
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->Detach();
35932
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 Py_INCREF(Py_None); resultobj = Py_None;
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35944 PyObject *obj;
35945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35946 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35947 Py_INCREF(obj);
35948 return Py_BuildValue((char *)"");
35949 }
35950 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35951 PyObject *resultobj;
35952 wxMenu *arg1 = (wxMenu *) NULL ;
35953 int arg2 = (int) wxID_ANY ;
35954 wxString const &arg3_defvalue = wxPyEmptyString ;
35955 wxString *arg3 = (wxString *) &arg3_defvalue ;
35956 wxString const &arg4_defvalue = wxPyEmptyString ;
35957 wxString *arg4 = (wxString *) &arg4_defvalue ;
35958 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35959 wxMenu *arg6 = (wxMenu *) NULL ;
35960 wxMenuItem *result;
35961 bool temp3 = false ;
35962 bool temp4 = false ;
35963 PyObject * obj0 = 0 ;
35964 PyObject * obj1 = 0 ;
35965 PyObject * obj2 = 0 ;
35966 PyObject * obj3 = 0 ;
35967 PyObject * obj4 = 0 ;
35968 PyObject * obj5 = 0 ;
35969 char *kwnames[] = {
35970 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35971 };
35972
35973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35974 if (obj0) {
35975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35976 if (SWIG_arg_fail(1)) SWIG_fail;
35977 }
35978 if (obj1) {
35979 {
35980 arg2 = (int)(SWIG_As_int(obj1));
35981 if (SWIG_arg_fail(2)) SWIG_fail;
35982 }
35983 }
35984 if (obj2) {
35985 {
35986 arg3 = wxString_in_helper(obj2);
35987 if (arg3 == NULL) SWIG_fail;
35988 temp3 = true;
35989 }
35990 }
35991 if (obj3) {
35992 {
35993 arg4 = wxString_in_helper(obj3);
35994 if (arg4 == NULL) SWIG_fail;
35995 temp4 = true;
35996 }
35997 }
35998 if (obj4) {
35999 {
36000 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36001 if (SWIG_arg_fail(5)) SWIG_fail;
36002 }
36003 }
36004 if (obj5) {
36005 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36006 if (SWIG_arg_fail(6)) SWIG_fail;
36007 }
36008 {
36009 PyThreadState* __tstate = wxPyBeginAllowThreads();
36010 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36011
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 {
36016 resultobj = wxPyMake_wxObject(result, 1);
36017 }
36018 {
36019 if (temp3)
36020 delete arg3;
36021 }
36022 {
36023 if (temp4)
36024 delete arg4;
36025 }
36026 return resultobj;
36027 fail:
36028 {
36029 if (temp3)
36030 delete arg3;
36031 }
36032 {
36033 if (temp4)
36034 delete arg4;
36035 }
36036 return NULL;
36037 }
36038
36039
36040 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36041 PyObject *resultobj;
36042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36043 wxMenu *result;
36044 PyObject * obj0 = 0 ;
36045 char *kwnames[] = {
36046 (char *) "self", NULL
36047 };
36048
36049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36051 if (SWIG_arg_fail(1)) SWIG_fail;
36052 {
36053 PyThreadState* __tstate = wxPyBeginAllowThreads();
36054 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36055
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 {
36060 resultobj = wxPyMake_wxObject(result, 0);
36061 }
36062 return resultobj;
36063 fail:
36064 return NULL;
36065 }
36066
36067
36068 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36069 PyObject *resultobj;
36070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36071 wxMenu *arg2 = (wxMenu *) 0 ;
36072 PyObject * obj0 = 0 ;
36073 PyObject * obj1 = 0 ;
36074 char *kwnames[] = {
36075 (char *) "self",(char *) "menu", NULL
36076 };
36077
36078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36080 if (SWIG_arg_fail(1)) SWIG_fail;
36081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(2)) SWIG_fail;
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 (arg1)->SetMenu(arg2);
36086
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 Py_INCREF(Py_None); resultobj = Py_None;
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj;
36099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36100 int arg2 ;
36101 PyObject * obj0 = 0 ;
36102 PyObject * obj1 = 0 ;
36103 char *kwnames[] = {
36104 (char *) "self",(char *) "id", NULL
36105 };
36106
36107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36109 if (SWIG_arg_fail(1)) SWIG_fail;
36110 {
36111 arg2 = (int)(SWIG_As_int(obj1));
36112 if (SWIG_arg_fail(2)) SWIG_fail;
36113 }
36114 {
36115 PyThreadState* __tstate = wxPyBeginAllowThreads();
36116 (arg1)->SetId(arg2);
36117
36118 wxPyEndAllowThreads(__tstate);
36119 if (PyErr_Occurred()) SWIG_fail;
36120 }
36121 Py_INCREF(Py_None); resultobj = Py_None;
36122 return resultobj;
36123 fail:
36124 return NULL;
36125 }
36126
36127
36128 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36129 PyObject *resultobj;
36130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36131 int result;
36132 PyObject * obj0 = 0 ;
36133 char *kwnames[] = {
36134 (char *) "self", NULL
36135 };
36136
36137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36139 if (SWIG_arg_fail(1)) SWIG_fail;
36140 {
36141 PyThreadState* __tstate = wxPyBeginAllowThreads();
36142 result = (int)((wxMenuItem const *)arg1)->GetId();
36143
36144 wxPyEndAllowThreads(__tstate);
36145 if (PyErr_Occurred()) SWIG_fail;
36146 }
36147 {
36148 resultobj = SWIG_From_int((int)(result));
36149 }
36150 return resultobj;
36151 fail:
36152 return NULL;
36153 }
36154
36155
36156 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36157 PyObject *resultobj;
36158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36159 bool result;
36160 PyObject * obj0 = 0 ;
36161 char *kwnames[] = {
36162 (char *) "self", NULL
36163 };
36164
36165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36167 if (SWIG_arg_fail(1)) SWIG_fail;
36168 {
36169 PyThreadState* __tstate = wxPyBeginAllowThreads();
36170 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36171
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 {
36176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36177 }
36178 return resultobj;
36179 fail:
36180 return NULL;
36181 }
36182
36183
36184 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36185 PyObject *resultobj;
36186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36187 wxString *arg2 = 0 ;
36188 bool temp2 = false ;
36189 PyObject * obj0 = 0 ;
36190 PyObject * obj1 = 0 ;
36191 char *kwnames[] = {
36192 (char *) "self",(char *) "str", NULL
36193 };
36194
36195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
36200 if (arg2 == NULL) SWIG_fail;
36201 temp2 = true;
36202 }
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 (arg1)->SetText((wxString const &)*arg2);
36206
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 Py_INCREF(Py_None); resultobj = Py_None;
36211 {
36212 if (temp2)
36213 delete arg2;
36214 }
36215 return resultobj;
36216 fail:
36217 {
36218 if (temp2)
36219 delete arg2;
36220 }
36221 return NULL;
36222 }
36223
36224
36225 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36226 PyObject *resultobj;
36227 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36228 wxString result;
36229 PyObject * obj0 = 0 ;
36230 char *kwnames[] = {
36231 (char *) "self", NULL
36232 };
36233
36234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36236 if (SWIG_arg_fail(1)) SWIG_fail;
36237 {
36238 PyThreadState* __tstate = wxPyBeginAllowThreads();
36239 result = ((wxMenuItem const *)arg1)->GetLabel();
36240
36241 wxPyEndAllowThreads(__tstate);
36242 if (PyErr_Occurred()) SWIG_fail;
36243 }
36244 {
36245 #if wxUSE_UNICODE
36246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36247 #else
36248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36249 #endif
36250 }
36251 return resultobj;
36252 fail:
36253 return NULL;
36254 }
36255
36256
36257 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36258 PyObject *resultobj;
36259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36260 wxString *result;
36261 PyObject * obj0 = 0 ;
36262 char *kwnames[] = {
36263 (char *) "self", NULL
36264 };
36265
36266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36268 if (SWIG_arg_fail(1)) SWIG_fail;
36269 {
36270 PyThreadState* __tstate = wxPyBeginAllowThreads();
36271 {
36272 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36273 result = (wxString *) &_result_ref;
36274 }
36275
36276 wxPyEndAllowThreads(__tstate);
36277 if (PyErr_Occurred()) SWIG_fail;
36278 }
36279 {
36280 #if wxUSE_UNICODE
36281 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36282 #else
36283 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36284 #endif
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36293 PyObject *resultobj;
36294 wxString *arg1 = 0 ;
36295 wxString result;
36296 bool temp1 = false ;
36297 PyObject * obj0 = 0 ;
36298 char *kwnames[] = {
36299 (char *) "text", NULL
36300 };
36301
36302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36303 {
36304 arg1 = wxString_in_helper(obj0);
36305 if (arg1 == NULL) SWIG_fail;
36306 temp1 = true;
36307 }
36308 {
36309 PyThreadState* __tstate = wxPyBeginAllowThreads();
36310 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36311
36312 wxPyEndAllowThreads(__tstate);
36313 if (PyErr_Occurred()) SWIG_fail;
36314 }
36315 {
36316 #if wxUSE_UNICODE
36317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36318 #else
36319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36320 #endif
36321 }
36322 {
36323 if (temp1)
36324 delete arg1;
36325 }
36326 return resultobj;
36327 fail:
36328 {
36329 if (temp1)
36330 delete arg1;
36331 }
36332 return NULL;
36333 }
36334
36335
36336 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj;
36338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36339 wxItemKind result;
36340 PyObject * obj0 = 0 ;
36341 char *kwnames[] = {
36342 (char *) "self", NULL
36343 };
36344
36345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36347 if (SWIG_arg_fail(1)) SWIG_fail;
36348 {
36349 PyThreadState* __tstate = wxPyBeginAllowThreads();
36350 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36351
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 resultobj = SWIG_From_int((result));
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36363 PyObject *resultobj;
36364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36365 wxItemKind arg2 ;
36366 PyObject * obj0 = 0 ;
36367 PyObject * obj1 = 0 ;
36368 char *kwnames[] = {
36369 (char *) "self",(char *) "kind", NULL
36370 };
36371
36372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36374 if (SWIG_arg_fail(1)) SWIG_fail;
36375 {
36376 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36377 if (SWIG_arg_fail(2)) SWIG_fail;
36378 }
36379 {
36380 PyThreadState* __tstate = wxPyBeginAllowThreads();
36381 (arg1)->SetKind((wxItemKind )arg2);
36382
36383 wxPyEndAllowThreads(__tstate);
36384 if (PyErr_Occurred()) SWIG_fail;
36385 }
36386 Py_INCREF(Py_None); resultobj = Py_None;
36387 return resultobj;
36388 fail:
36389 return NULL;
36390 }
36391
36392
36393 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36394 PyObject *resultobj;
36395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36396 bool arg2 ;
36397 PyObject * obj0 = 0 ;
36398 PyObject * obj1 = 0 ;
36399 char *kwnames[] = {
36400 (char *) "self",(char *) "checkable", NULL
36401 };
36402
36403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36405 if (SWIG_arg_fail(1)) SWIG_fail;
36406 {
36407 arg2 = (bool)(SWIG_As_bool(obj1));
36408 if (SWIG_arg_fail(2)) SWIG_fail;
36409 }
36410 {
36411 PyThreadState* __tstate = wxPyBeginAllowThreads();
36412 (arg1)->SetCheckable(arg2);
36413
36414 wxPyEndAllowThreads(__tstate);
36415 if (PyErr_Occurred()) SWIG_fail;
36416 }
36417 Py_INCREF(Py_None); resultobj = Py_None;
36418 return resultobj;
36419 fail:
36420 return NULL;
36421 }
36422
36423
36424 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36425 PyObject *resultobj;
36426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36427 bool result;
36428 PyObject * obj0 = 0 ;
36429 char *kwnames[] = {
36430 (char *) "self", NULL
36431 };
36432
36433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36435 if (SWIG_arg_fail(1)) SWIG_fail;
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36439
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 {
36444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36445 }
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36453 PyObject *resultobj;
36454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36455 bool result;
36456 PyObject * obj0 = 0 ;
36457 char *kwnames[] = {
36458 (char *) "self", NULL
36459 };
36460
36461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36463 if (SWIG_arg_fail(1)) SWIG_fail;
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36467
36468 wxPyEndAllowThreads(__tstate);
36469 if (PyErr_Occurred()) SWIG_fail;
36470 }
36471 {
36472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36473 }
36474 return resultobj;
36475 fail:
36476 return NULL;
36477 }
36478
36479
36480 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36481 PyObject *resultobj;
36482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36483 wxMenu *arg2 = (wxMenu *) 0 ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char *kwnames[] = {
36487 (char *) "self",(char *) "menu", NULL
36488 };
36489
36490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36494 if (SWIG_arg_fail(2)) SWIG_fail;
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 (arg1)->SetSubMenu(arg2);
36498
36499 wxPyEndAllowThreads(__tstate);
36500 if (PyErr_Occurred()) SWIG_fail;
36501 }
36502 Py_INCREF(Py_None); resultobj = Py_None;
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj;
36511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36512 wxMenu *result;
36513 PyObject * obj0 = 0 ;
36514 char *kwnames[] = {
36515 (char *) "self", NULL
36516 };
36517
36518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36520 if (SWIG_arg_fail(1)) SWIG_fail;
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36524
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 {
36529 resultobj = wxPyMake_wxObject(result, 0);
36530 }
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj;
36539 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36540 bool arg2 = (bool) true ;
36541 PyObject * obj0 = 0 ;
36542 PyObject * obj1 = 0 ;
36543 char *kwnames[] = {
36544 (char *) "self",(char *) "enable", NULL
36545 };
36546
36547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36549 if (SWIG_arg_fail(1)) SWIG_fail;
36550 if (obj1) {
36551 {
36552 arg2 = (bool)(SWIG_As_bool(obj1));
36553 if (SWIG_arg_fail(2)) SWIG_fail;
36554 }
36555 }
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 (arg1)->Enable(arg2);
36559
36560 wxPyEndAllowThreads(__tstate);
36561 if (PyErr_Occurred()) SWIG_fail;
36562 }
36563 Py_INCREF(Py_None); resultobj = Py_None;
36564 return resultobj;
36565 fail:
36566 return NULL;
36567 }
36568
36569
36570 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36571 PyObject *resultobj;
36572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36573 bool result;
36574 PyObject * obj0 = 0 ;
36575 char *kwnames[] = {
36576 (char *) "self", NULL
36577 };
36578
36579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36581 if (SWIG_arg_fail(1)) SWIG_fail;
36582 {
36583 PyThreadState* __tstate = wxPyBeginAllowThreads();
36584 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36585
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 {
36590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36591 }
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36599 PyObject *resultobj;
36600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36601 bool arg2 = (bool) true ;
36602 PyObject * obj0 = 0 ;
36603 PyObject * obj1 = 0 ;
36604 char *kwnames[] = {
36605 (char *) "self",(char *) "check", NULL
36606 };
36607
36608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36610 if (SWIG_arg_fail(1)) SWIG_fail;
36611 if (obj1) {
36612 {
36613 arg2 = (bool)(SWIG_As_bool(obj1));
36614 if (SWIG_arg_fail(2)) SWIG_fail;
36615 }
36616 }
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 (arg1)->Check(arg2);
36620
36621 wxPyEndAllowThreads(__tstate);
36622 if (PyErr_Occurred()) SWIG_fail;
36623 }
36624 Py_INCREF(Py_None); resultobj = Py_None;
36625 return resultobj;
36626 fail:
36627 return NULL;
36628 }
36629
36630
36631 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36632 PyObject *resultobj;
36633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36634 bool result;
36635 PyObject * obj0 = 0 ;
36636 char *kwnames[] = {
36637 (char *) "self", NULL
36638 };
36639
36640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36642 if (SWIG_arg_fail(1)) SWIG_fail;
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36646
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 {
36651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36652 }
36653 return resultobj;
36654 fail:
36655 return NULL;
36656 }
36657
36658
36659 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36660 PyObject *resultobj;
36661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36662 PyObject * obj0 = 0 ;
36663 char *kwnames[] = {
36664 (char *) "self", NULL
36665 };
36666
36667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36669 if (SWIG_arg_fail(1)) SWIG_fail;
36670 {
36671 PyThreadState* __tstate = wxPyBeginAllowThreads();
36672 (arg1)->Toggle();
36673
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 Py_INCREF(Py_None); resultobj = Py_None;
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36685 PyObject *resultobj;
36686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36687 wxString *arg2 = 0 ;
36688 bool temp2 = false ;
36689 PyObject * obj0 = 0 ;
36690 PyObject * obj1 = 0 ;
36691 char *kwnames[] = {
36692 (char *) "self",(char *) "str", NULL
36693 };
36694
36695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36697 if (SWIG_arg_fail(1)) SWIG_fail;
36698 {
36699 arg2 = wxString_in_helper(obj1);
36700 if (arg2 == NULL) SWIG_fail;
36701 temp2 = true;
36702 }
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 (arg1)->SetHelp((wxString const &)*arg2);
36706
36707 wxPyEndAllowThreads(__tstate);
36708 if (PyErr_Occurred()) SWIG_fail;
36709 }
36710 Py_INCREF(Py_None); resultobj = Py_None;
36711 {
36712 if (temp2)
36713 delete arg2;
36714 }
36715 return resultobj;
36716 fail:
36717 {
36718 if (temp2)
36719 delete arg2;
36720 }
36721 return NULL;
36722 }
36723
36724
36725 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36726 PyObject *resultobj;
36727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36728 wxString *result;
36729 PyObject * obj0 = 0 ;
36730 char *kwnames[] = {
36731 (char *) "self", NULL
36732 };
36733
36734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36736 if (SWIG_arg_fail(1)) SWIG_fail;
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 {
36740 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36741 result = (wxString *) &_result_ref;
36742 }
36743
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 {
36748 #if wxUSE_UNICODE
36749 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36750 #else
36751 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36752 #endif
36753 }
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36761 PyObject *resultobj;
36762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36763 wxAcceleratorEntry *result;
36764 PyObject * obj0 = 0 ;
36765 char *kwnames[] = {
36766 (char *) "self", NULL
36767 };
36768
36769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36771 if (SWIG_arg_fail(1)) SWIG_fail;
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36775
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36787 PyObject *resultobj;
36788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36789 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36790 PyObject * obj0 = 0 ;
36791 PyObject * obj1 = 0 ;
36792 char *kwnames[] = {
36793 (char *) "self",(char *) "accel", NULL
36794 };
36795
36796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36798 if (SWIG_arg_fail(1)) SWIG_fail;
36799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36800 if (SWIG_arg_fail(2)) SWIG_fail;
36801 {
36802 PyThreadState* __tstate = wxPyBeginAllowThreads();
36803 (arg1)->SetAccel(arg2);
36804
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 Py_INCREF(Py_None); resultobj = Py_None;
36809 return resultobj;
36810 fail:
36811 return NULL;
36812 }
36813
36814
36815 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36816 PyObject *resultobj;
36817 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36818 wxFont *arg2 = 0 ;
36819 PyObject * obj0 = 0 ;
36820 PyObject * obj1 = 0 ;
36821 char *kwnames[] = {
36822 (char *) "self",(char *) "font", NULL
36823 };
36824
36825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36827 if (SWIG_arg_fail(1)) SWIG_fail;
36828 {
36829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36830 if (SWIG_arg_fail(2)) SWIG_fail;
36831 if (arg2 == NULL) {
36832 SWIG_null_ref("wxFont");
36833 }
36834 if (SWIG_arg_fail(2)) SWIG_fail;
36835 }
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 (arg1)->SetFont((wxFont const &)*arg2);
36839
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 Py_INCREF(Py_None); resultobj = Py_None;
36844 return resultobj;
36845 fail:
36846 return NULL;
36847 }
36848
36849
36850 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36851 PyObject *resultobj;
36852 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36853 wxFont result;
36854 PyObject * obj0 = 0 ;
36855 char *kwnames[] = {
36856 (char *) "self", NULL
36857 };
36858
36859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36861 if (SWIG_arg_fail(1)) SWIG_fail;
36862 {
36863 PyThreadState* __tstate = wxPyBeginAllowThreads();
36864 result = (arg1)->GetFont();
36865
36866 wxPyEndAllowThreads(__tstate);
36867 if (PyErr_Occurred()) SWIG_fail;
36868 }
36869 {
36870 wxFont * resultptr;
36871 resultptr = new wxFont((wxFont &)(result));
36872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36873 }
36874 return resultobj;
36875 fail:
36876 return NULL;
36877 }
36878
36879
36880 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36881 PyObject *resultobj;
36882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36883 wxColour *arg2 = 0 ;
36884 wxColour temp2 ;
36885 PyObject * obj0 = 0 ;
36886 PyObject * obj1 = 0 ;
36887 char *kwnames[] = {
36888 (char *) "self",(char *) "colText", NULL
36889 };
36890
36891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36893 if (SWIG_arg_fail(1)) SWIG_fail;
36894 {
36895 arg2 = &temp2;
36896 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36897 }
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 (arg1)->SetTextColour((wxColour const &)*arg2);
36901
36902 wxPyEndAllowThreads(__tstate);
36903 if (PyErr_Occurred()) SWIG_fail;
36904 }
36905 Py_INCREF(Py_None); resultobj = Py_None;
36906 return resultobj;
36907 fail:
36908 return NULL;
36909 }
36910
36911
36912 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36913 PyObject *resultobj;
36914 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36915 wxColour result;
36916 PyObject * obj0 = 0 ;
36917 char *kwnames[] = {
36918 (char *) "self", NULL
36919 };
36920
36921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36923 if (SWIG_arg_fail(1)) SWIG_fail;
36924 {
36925 PyThreadState* __tstate = wxPyBeginAllowThreads();
36926 result = (arg1)->GetTextColour();
36927
36928 wxPyEndAllowThreads(__tstate);
36929 if (PyErr_Occurred()) SWIG_fail;
36930 }
36931 {
36932 wxColour * resultptr;
36933 resultptr = new wxColour((wxColour &)(result));
36934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36935 }
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36943 PyObject *resultobj;
36944 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36945 wxColour *arg2 = 0 ;
36946 wxColour temp2 ;
36947 PyObject * obj0 = 0 ;
36948 PyObject * obj1 = 0 ;
36949 char *kwnames[] = {
36950 (char *) "self",(char *) "colBack", NULL
36951 };
36952
36953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36955 if (SWIG_arg_fail(1)) SWIG_fail;
36956 {
36957 arg2 = &temp2;
36958 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36959 }
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36963
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 Py_INCREF(Py_None); resultobj = Py_None;
36968 return resultobj;
36969 fail:
36970 return NULL;
36971 }
36972
36973
36974 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36975 PyObject *resultobj;
36976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36977 wxColour result;
36978 PyObject * obj0 = 0 ;
36979 char *kwnames[] = {
36980 (char *) "self", NULL
36981 };
36982
36983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36985 if (SWIG_arg_fail(1)) SWIG_fail;
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 result = (arg1)->GetBackgroundColour();
36989
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 {
36994 wxColour * resultptr;
36995 resultptr = new wxColour((wxColour &)(result));
36996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36997 }
36998 return resultobj;
36999 fail:
37000 return NULL;
37001 }
37002
37003
37004 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37005 PyObject *resultobj;
37006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37007 wxBitmap *arg2 = 0 ;
37008 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37009 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37010 PyObject * obj0 = 0 ;
37011 PyObject * obj1 = 0 ;
37012 PyObject * obj2 = 0 ;
37013 char *kwnames[] = {
37014 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37015 };
37016
37017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37019 if (SWIG_arg_fail(1)) SWIG_fail;
37020 {
37021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37022 if (SWIG_arg_fail(2)) SWIG_fail;
37023 if (arg2 == NULL) {
37024 SWIG_null_ref("wxBitmap");
37025 }
37026 if (SWIG_arg_fail(2)) SWIG_fail;
37027 }
37028 if (obj2) {
37029 {
37030 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(3)) SWIG_fail;
37032 if (arg3 == NULL) {
37033 SWIG_null_ref("wxBitmap");
37034 }
37035 if (SWIG_arg_fail(3)) SWIG_fail;
37036 }
37037 }
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37041
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 Py_INCREF(Py_None); resultobj = Py_None;
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj;
37054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37055 wxBitmap *arg2 = 0 ;
37056 PyObject * obj0 = 0 ;
37057 PyObject * obj1 = 0 ;
37058 char *kwnames[] = {
37059 (char *) "self",(char *) "bmpDisabled", NULL
37060 };
37061
37062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37064 if (SWIG_arg_fail(1)) SWIG_fail;
37065 {
37066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37067 if (SWIG_arg_fail(2)) SWIG_fail;
37068 if (arg2 == NULL) {
37069 SWIG_null_ref("wxBitmap");
37070 }
37071 if (SWIG_arg_fail(2)) SWIG_fail;
37072 }
37073 {
37074 PyThreadState* __tstate = wxPyBeginAllowThreads();
37075 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37076
37077 wxPyEndAllowThreads(__tstate);
37078 if (PyErr_Occurred()) SWIG_fail;
37079 }
37080 Py_INCREF(Py_None); resultobj = Py_None;
37081 return resultobj;
37082 fail:
37083 return NULL;
37084 }
37085
37086
37087 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37088 PyObject *resultobj;
37089 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37090 wxBitmap *result;
37091 PyObject * obj0 = 0 ;
37092 char *kwnames[] = {
37093 (char *) "self", NULL
37094 };
37095
37096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37098 if (SWIG_arg_fail(1)) SWIG_fail;
37099 {
37100 PyThreadState* __tstate = wxPyBeginAllowThreads();
37101 {
37102 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37103 result = (wxBitmap *) &_result_ref;
37104 }
37105
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 {
37110 wxBitmap* resultptr = new wxBitmap(*result);
37111 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37112 }
37113 return resultobj;
37114 fail:
37115 return NULL;
37116 }
37117
37118
37119 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37120 PyObject *resultobj;
37121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37122 int arg2 ;
37123 PyObject * obj0 = 0 ;
37124 PyObject * obj1 = 0 ;
37125 char *kwnames[] = {
37126 (char *) "self",(char *) "nWidth", NULL
37127 };
37128
37129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37131 if (SWIG_arg_fail(1)) SWIG_fail;
37132 {
37133 arg2 = (int)(SWIG_As_int(obj1));
37134 if (SWIG_arg_fail(2)) SWIG_fail;
37135 }
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 (arg1)->SetMarginWidth(arg2);
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 Py_INCREF(Py_None); resultobj = Py_None;
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37151 PyObject *resultobj;
37152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37153 int result;
37154 PyObject * obj0 = 0 ;
37155 char *kwnames[] = {
37156 (char *) "self", NULL
37157 };
37158
37159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37161 if (SWIG_arg_fail(1)) SWIG_fail;
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 result = (int)(arg1)->GetMarginWidth();
37165
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 {
37170 resultobj = SWIG_From_int((int)(result));
37171 }
37172 return resultobj;
37173 fail:
37174 return NULL;
37175 }
37176
37177
37178 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37179 PyObject *resultobj;
37180 int result;
37181 char *kwnames[] = {
37182 NULL
37183 };
37184
37185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (int)wxMenuItem::GetDefaultMarginWidth();
37189
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 {
37194 resultobj = SWIG_From_int((int)(result));
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37203 PyObject *resultobj;
37204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37205 bool result;
37206 PyObject * obj0 = 0 ;
37207 char *kwnames[] = {
37208 (char *) "self", NULL
37209 };
37210
37211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37213 if (SWIG_arg_fail(1)) SWIG_fail;
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 result = (bool)(arg1)->IsOwnerDrawn();
37217
37218 wxPyEndAllowThreads(__tstate);
37219 if (PyErr_Occurred()) SWIG_fail;
37220 }
37221 {
37222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37223 }
37224 return resultobj;
37225 fail:
37226 return NULL;
37227 }
37228
37229
37230 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37231 PyObject *resultobj;
37232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37233 bool arg2 = (bool) true ;
37234 PyObject * obj0 = 0 ;
37235 PyObject * obj1 = 0 ;
37236 char *kwnames[] = {
37237 (char *) "self",(char *) "ownerDrawn", NULL
37238 };
37239
37240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37242 if (SWIG_arg_fail(1)) SWIG_fail;
37243 if (obj1) {
37244 {
37245 arg2 = (bool)(SWIG_As_bool(obj1));
37246 if (SWIG_arg_fail(2)) SWIG_fail;
37247 }
37248 }
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 (arg1)->SetOwnerDrawn(arg2);
37252
37253 wxPyEndAllowThreads(__tstate);
37254 if (PyErr_Occurred()) SWIG_fail;
37255 }
37256 Py_INCREF(Py_None); resultobj = Py_None;
37257 return resultobj;
37258 fail:
37259 return NULL;
37260 }
37261
37262
37263 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37266 PyObject * obj0 = 0 ;
37267 char *kwnames[] = {
37268 (char *) "self", NULL
37269 };
37270
37271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37273 if (SWIG_arg_fail(1)) SWIG_fail;
37274 {
37275 PyThreadState* __tstate = wxPyBeginAllowThreads();
37276 (arg1)->ResetOwnerDrawn();
37277
37278 wxPyEndAllowThreads(__tstate);
37279 if (PyErr_Occurred()) SWIG_fail;
37280 }
37281 Py_INCREF(Py_None); resultobj = Py_None;
37282 return resultobj;
37283 fail:
37284 return NULL;
37285 }
37286
37287
37288 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37289 PyObject *resultobj;
37290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37291 wxBitmap *arg2 = 0 ;
37292 PyObject * obj0 = 0 ;
37293 PyObject * obj1 = 0 ;
37294 char *kwnames[] = {
37295 (char *) "self",(char *) "bitmap", NULL
37296 };
37297
37298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37300 if (SWIG_arg_fail(1)) SWIG_fail;
37301 {
37302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37303 if (SWIG_arg_fail(2)) SWIG_fail;
37304 if (arg2 == NULL) {
37305 SWIG_null_ref("wxBitmap");
37306 }
37307 if (SWIG_arg_fail(2)) SWIG_fail;
37308 }
37309 {
37310 PyThreadState* __tstate = wxPyBeginAllowThreads();
37311 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37312
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 Py_INCREF(Py_None); resultobj = Py_None;
37317 return resultobj;
37318 fail:
37319 return NULL;
37320 }
37321
37322
37323 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37324 PyObject *resultobj;
37325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37326 wxBitmap *result;
37327 PyObject * obj0 = 0 ;
37328 char *kwnames[] = {
37329 (char *) "self", NULL
37330 };
37331
37332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37334 if (SWIG_arg_fail(1)) SWIG_fail;
37335 {
37336 PyThreadState* __tstate = wxPyBeginAllowThreads();
37337 {
37338 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37339 result = (wxBitmap *) &_result_ref;
37340 }
37341
37342 wxPyEndAllowThreads(__tstate);
37343 if (PyErr_Occurred()) SWIG_fail;
37344 }
37345 {
37346 wxBitmap* resultptr = new wxBitmap(*result);
37347 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37348 }
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37356 PyObject *obj;
37357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37358 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37359 Py_INCREF(obj);
37360 return Py_BuildValue((char *)"");
37361 }
37362 static int _wrap_ControlNameStr_set(PyObject *) {
37363 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37364 return 1;
37365 }
37366
37367
37368 static PyObject *_wrap_ControlNameStr_get(void) {
37369 PyObject *pyobj;
37370
37371 {
37372 #if wxUSE_UNICODE
37373 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37374 #else
37375 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37376 #endif
37377 }
37378 return pyobj;
37379 }
37380
37381
37382 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37383 PyObject *resultobj;
37384 wxWindow *arg1 = (wxWindow *) 0 ;
37385 int arg2 = (int) -1 ;
37386 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37387 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37388 wxSize const &arg4_defvalue = wxDefaultSize ;
37389 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37390 long arg5 = (long) 0 ;
37391 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37392 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37393 wxString const &arg7_defvalue = wxPyControlNameStr ;
37394 wxString *arg7 = (wxString *) &arg7_defvalue ;
37395 wxControl *result;
37396 wxPoint temp3 ;
37397 wxSize temp4 ;
37398 bool temp7 = false ;
37399 PyObject * obj0 = 0 ;
37400 PyObject * obj1 = 0 ;
37401 PyObject * obj2 = 0 ;
37402 PyObject * obj3 = 0 ;
37403 PyObject * obj4 = 0 ;
37404 PyObject * obj5 = 0 ;
37405 PyObject * obj6 = 0 ;
37406 char *kwnames[] = {
37407 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37408 };
37409
37410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37412 if (SWIG_arg_fail(1)) SWIG_fail;
37413 if (obj1) {
37414 {
37415 arg2 = (int)(SWIG_As_int(obj1));
37416 if (SWIG_arg_fail(2)) SWIG_fail;
37417 }
37418 }
37419 if (obj2) {
37420 {
37421 arg3 = &temp3;
37422 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37423 }
37424 }
37425 if (obj3) {
37426 {
37427 arg4 = &temp4;
37428 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37429 }
37430 }
37431 if (obj4) {
37432 {
37433 arg5 = (long)(SWIG_As_long(obj4));
37434 if (SWIG_arg_fail(5)) SWIG_fail;
37435 }
37436 }
37437 if (obj5) {
37438 {
37439 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37440 if (SWIG_arg_fail(6)) SWIG_fail;
37441 if (arg6 == NULL) {
37442 SWIG_null_ref("wxValidator");
37443 }
37444 if (SWIG_arg_fail(6)) SWIG_fail;
37445 }
37446 }
37447 if (obj6) {
37448 {
37449 arg7 = wxString_in_helper(obj6);
37450 if (arg7 == NULL) SWIG_fail;
37451 temp7 = true;
37452 }
37453 }
37454 {
37455 if (!wxPyCheckForApp()) SWIG_fail;
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37458
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37463 {
37464 if (temp7)
37465 delete arg7;
37466 }
37467 return resultobj;
37468 fail:
37469 {
37470 if (temp7)
37471 delete arg7;
37472 }
37473 return NULL;
37474 }
37475
37476
37477 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37478 PyObject *resultobj;
37479 wxControl *result;
37480 char *kwnames[] = {
37481 NULL
37482 };
37483
37484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37485 {
37486 if (!wxPyCheckForApp()) SWIG_fail;
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 result = (wxControl *)new wxControl();
37489
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37501 PyObject *resultobj;
37502 wxControl *arg1 = (wxControl *) 0 ;
37503 wxWindow *arg2 = (wxWindow *) 0 ;
37504 int arg3 = (int) -1 ;
37505 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37506 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37507 wxSize const &arg5_defvalue = wxDefaultSize ;
37508 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37509 long arg6 = (long) 0 ;
37510 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37511 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37512 wxString const &arg8_defvalue = wxPyControlNameStr ;
37513 wxString *arg8 = (wxString *) &arg8_defvalue ;
37514 bool result;
37515 wxPoint temp4 ;
37516 wxSize temp5 ;
37517 bool temp8 = false ;
37518 PyObject * obj0 = 0 ;
37519 PyObject * obj1 = 0 ;
37520 PyObject * obj2 = 0 ;
37521 PyObject * obj3 = 0 ;
37522 PyObject * obj4 = 0 ;
37523 PyObject * obj5 = 0 ;
37524 PyObject * obj6 = 0 ;
37525 PyObject * obj7 = 0 ;
37526 char *kwnames[] = {
37527 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37528 };
37529
37530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37532 if (SWIG_arg_fail(1)) SWIG_fail;
37533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37534 if (SWIG_arg_fail(2)) SWIG_fail;
37535 if (obj2) {
37536 {
37537 arg3 = (int)(SWIG_As_int(obj2));
37538 if (SWIG_arg_fail(3)) SWIG_fail;
37539 }
37540 }
37541 if (obj3) {
37542 {
37543 arg4 = &temp4;
37544 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37545 }
37546 }
37547 if (obj4) {
37548 {
37549 arg5 = &temp5;
37550 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37551 }
37552 }
37553 if (obj5) {
37554 {
37555 arg6 = (long)(SWIG_As_long(obj5));
37556 if (SWIG_arg_fail(6)) SWIG_fail;
37557 }
37558 }
37559 if (obj6) {
37560 {
37561 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37562 if (SWIG_arg_fail(7)) SWIG_fail;
37563 if (arg7 == NULL) {
37564 SWIG_null_ref("wxValidator");
37565 }
37566 if (SWIG_arg_fail(7)) SWIG_fail;
37567 }
37568 }
37569 if (obj7) {
37570 {
37571 arg8 = wxString_in_helper(obj7);
37572 if (arg8 == NULL) SWIG_fail;
37573 temp8 = true;
37574 }
37575 }
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37579
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 {
37584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37585 }
37586 {
37587 if (temp8)
37588 delete arg8;
37589 }
37590 return resultobj;
37591 fail:
37592 {
37593 if (temp8)
37594 delete arg8;
37595 }
37596 return NULL;
37597 }
37598
37599
37600 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37601 PyObject *resultobj;
37602 wxControl *arg1 = (wxControl *) 0 ;
37603 wxCommandEvent *arg2 = 0 ;
37604 PyObject * obj0 = 0 ;
37605 PyObject * obj1 = 0 ;
37606 char *kwnames[] = {
37607 (char *) "self",(char *) "event", NULL
37608 };
37609
37610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37612 if (SWIG_arg_fail(1)) SWIG_fail;
37613 {
37614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37615 if (SWIG_arg_fail(2)) SWIG_fail;
37616 if (arg2 == NULL) {
37617 SWIG_null_ref("wxCommandEvent");
37618 }
37619 if (SWIG_arg_fail(2)) SWIG_fail;
37620 }
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 (arg1)->Command(*arg2);
37624
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 Py_INCREF(Py_None); resultobj = Py_None;
37629 return resultobj;
37630 fail:
37631 return NULL;
37632 }
37633
37634
37635 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37636 PyObject *resultobj;
37637 wxControl *arg1 = (wxControl *) 0 ;
37638 wxString result;
37639 PyObject * obj0 = 0 ;
37640 char *kwnames[] = {
37641 (char *) "self", NULL
37642 };
37643
37644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37646 if (SWIG_arg_fail(1)) SWIG_fail;
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (arg1)->GetLabel();
37650
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 {
37655 #if wxUSE_UNICODE
37656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37657 #else
37658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37659 #endif
37660 }
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj;
37669 wxControl *arg1 = (wxControl *) 0 ;
37670 wxString *arg2 = 0 ;
37671 bool temp2 = false ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 char *kwnames[] = {
37675 (char *) "self",(char *) "label", NULL
37676 };
37677
37678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37680 if (SWIG_arg_fail(1)) SWIG_fail;
37681 {
37682 arg2 = wxString_in_helper(obj1);
37683 if (arg2 == NULL) SWIG_fail;
37684 temp2 = true;
37685 }
37686 {
37687 PyThreadState* __tstate = wxPyBeginAllowThreads();
37688 (arg1)->SetLabel((wxString const &)*arg2);
37689
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 Py_INCREF(Py_None); resultobj = Py_None;
37694 {
37695 if (temp2)
37696 delete arg2;
37697 }
37698 return resultobj;
37699 fail:
37700 {
37701 if (temp2)
37702 delete arg2;
37703 }
37704 return NULL;
37705 }
37706
37707
37708 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37709 PyObject *resultobj;
37710 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37711 wxVisualAttributes result;
37712 PyObject * obj0 = 0 ;
37713 char *kwnames[] = {
37714 (char *) "variant", NULL
37715 };
37716
37717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37718 if (obj0) {
37719 {
37720 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37721 if (SWIG_arg_fail(1)) SWIG_fail;
37722 }
37723 }
37724 {
37725 if (!wxPyCheckForApp()) SWIG_fail;
37726 PyThreadState* __tstate = wxPyBeginAllowThreads();
37727 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37728
37729 wxPyEndAllowThreads(__tstate);
37730 if (PyErr_Occurred()) SWIG_fail;
37731 }
37732 {
37733 wxVisualAttributes * resultptr;
37734 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37735 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37744 PyObject *obj;
37745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37746 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37747 Py_INCREF(obj);
37748 return Py_BuildValue((char *)"");
37749 }
37750 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37751 PyObject *resultobj;
37752 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37753 wxString *arg2 = 0 ;
37754 PyObject *arg3 = (PyObject *) NULL ;
37755 int result;
37756 bool temp2 = false ;
37757 PyObject * obj0 = 0 ;
37758 PyObject * obj1 = 0 ;
37759 PyObject * obj2 = 0 ;
37760 char *kwnames[] = {
37761 (char *) "self",(char *) "item",(char *) "clientData", NULL
37762 };
37763
37764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37766 if (SWIG_arg_fail(1)) SWIG_fail;
37767 {
37768 arg2 = wxString_in_helper(obj1);
37769 if (arg2 == NULL) SWIG_fail;
37770 temp2 = true;
37771 }
37772 if (obj2) {
37773 arg3 = obj2;
37774 }
37775 {
37776 PyThreadState* __tstate = wxPyBeginAllowThreads();
37777 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37778
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = SWIG_From_int((int)(result));
37784 }
37785 {
37786 if (temp2)
37787 delete arg2;
37788 }
37789 return resultobj;
37790 fail:
37791 {
37792 if (temp2)
37793 delete arg2;
37794 }
37795 return NULL;
37796 }
37797
37798
37799 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj;
37801 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37802 wxArrayString *arg2 = 0 ;
37803 bool temp2 = false ;
37804 PyObject * obj0 = 0 ;
37805 PyObject * obj1 = 0 ;
37806 char *kwnames[] = {
37807 (char *) "self",(char *) "strings", NULL
37808 };
37809
37810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37812 if (SWIG_arg_fail(1)) SWIG_fail;
37813 {
37814 if (! PySequence_Check(obj1)) {
37815 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37816 SWIG_fail;
37817 }
37818 arg2 = new wxArrayString;
37819 temp2 = true;
37820 int i, len=PySequence_Length(obj1);
37821 for (i=0; i<len; i++) {
37822 PyObject* item = PySequence_GetItem(obj1, i);
37823 #if wxUSE_UNICODE
37824 PyObject* str = PyObject_Unicode(item);
37825 #else
37826 PyObject* str = PyObject_Str(item);
37827 #endif
37828 if (PyErr_Occurred()) SWIG_fail;
37829 arg2->Add(Py2wxString(str));
37830 Py_DECREF(item);
37831 Py_DECREF(str);
37832 }
37833 }
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 (arg1)->Append((wxArrayString const &)*arg2);
37837
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 Py_INCREF(Py_None); resultobj = Py_None;
37842 {
37843 if (temp2) delete arg2;
37844 }
37845 return resultobj;
37846 fail:
37847 {
37848 if (temp2) delete arg2;
37849 }
37850 return NULL;
37851 }
37852
37853
37854 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37855 PyObject *resultobj;
37856 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37857 wxString *arg2 = 0 ;
37858 int arg3 ;
37859 PyObject *arg4 = (PyObject *) NULL ;
37860 int result;
37861 bool temp2 = false ;
37862 PyObject * obj0 = 0 ;
37863 PyObject * obj1 = 0 ;
37864 PyObject * obj2 = 0 ;
37865 PyObject * obj3 = 0 ;
37866 char *kwnames[] = {
37867 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37868 };
37869
37870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37872 if (SWIG_arg_fail(1)) SWIG_fail;
37873 {
37874 arg2 = wxString_in_helper(obj1);
37875 if (arg2 == NULL) SWIG_fail;
37876 temp2 = true;
37877 }
37878 {
37879 arg3 = (int)(SWIG_As_int(obj2));
37880 if (SWIG_arg_fail(3)) SWIG_fail;
37881 }
37882 if (obj3) {
37883 arg4 = obj3;
37884 }
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37888
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 {
37893 resultobj = SWIG_From_int((int)(result));
37894 }
37895 {
37896 if (temp2)
37897 delete arg2;
37898 }
37899 return resultobj;
37900 fail:
37901 {
37902 if (temp2)
37903 delete arg2;
37904 }
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37912 PyObject * obj0 = 0 ;
37913 char *kwnames[] = {
37914 (char *) "self", NULL
37915 };
37916
37917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37919 if (SWIG_arg_fail(1)) SWIG_fail;
37920 {
37921 PyThreadState* __tstate = wxPyBeginAllowThreads();
37922 (arg1)->Clear();
37923
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 Py_INCREF(Py_None); resultobj = Py_None;
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37935 PyObject *resultobj;
37936 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37937 int arg2 ;
37938 PyObject * obj0 = 0 ;
37939 PyObject * obj1 = 0 ;
37940 char *kwnames[] = {
37941 (char *) "self",(char *) "n", NULL
37942 };
37943
37944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37946 if (SWIG_arg_fail(1)) SWIG_fail;
37947 {
37948 arg2 = (int)(SWIG_As_int(obj1));
37949 if (SWIG_arg_fail(2)) SWIG_fail;
37950 }
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 (arg1)->Delete(arg2);
37954
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 Py_INCREF(Py_None); resultobj = Py_None;
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37966 PyObject *resultobj;
37967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37968 int arg2 ;
37969 PyObject *result;
37970 PyObject * obj0 = 0 ;
37971 PyObject * obj1 = 0 ;
37972 char *kwnames[] = {
37973 (char *) "self",(char *) "n", NULL
37974 };
37975
37976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37978 if (SWIG_arg_fail(1)) SWIG_fail;
37979 {
37980 arg2 = (int)(SWIG_As_int(obj1));
37981 if (SWIG_arg_fail(2)) SWIG_fail;
37982 }
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37986
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 resultobj = result;
37991 return resultobj;
37992 fail:
37993 return NULL;
37994 }
37995
37996
37997 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37998 PyObject *resultobj;
37999 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38000 int arg2 ;
38001 PyObject *arg3 = (PyObject *) 0 ;
38002 PyObject * obj0 = 0 ;
38003 PyObject * obj1 = 0 ;
38004 PyObject * obj2 = 0 ;
38005 char *kwnames[] = {
38006 (char *) "self",(char *) "n",(char *) "clientData", NULL
38007 };
38008
38009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38011 if (SWIG_arg_fail(1)) SWIG_fail;
38012 {
38013 arg2 = (int)(SWIG_As_int(obj1));
38014 if (SWIG_arg_fail(2)) SWIG_fail;
38015 }
38016 arg3 = obj2;
38017 {
38018 PyThreadState* __tstate = wxPyBeginAllowThreads();
38019 wxItemContainer_SetClientData(arg1,arg2,arg3);
38020
38021 wxPyEndAllowThreads(__tstate);
38022 if (PyErr_Occurred()) SWIG_fail;
38023 }
38024 Py_INCREF(Py_None); resultobj = Py_None;
38025 return resultobj;
38026 fail:
38027 return NULL;
38028 }
38029
38030
38031 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38032 PyObject *resultobj;
38033 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38034 int result;
38035 PyObject * obj0 = 0 ;
38036 char *kwnames[] = {
38037 (char *) "self", NULL
38038 };
38039
38040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38042 if (SWIG_arg_fail(1)) SWIG_fail;
38043 {
38044 PyThreadState* __tstate = wxPyBeginAllowThreads();
38045 result = (int)((wxItemContainer const *)arg1)->GetCount();
38046
38047 wxPyEndAllowThreads(__tstate);
38048 if (PyErr_Occurred()) SWIG_fail;
38049 }
38050 {
38051 resultobj = SWIG_From_int((int)(result));
38052 }
38053 return resultobj;
38054 fail:
38055 return NULL;
38056 }
38057
38058
38059 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38060 PyObject *resultobj;
38061 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38062 bool result;
38063 PyObject * obj0 = 0 ;
38064 char *kwnames[] = {
38065 (char *) "self", NULL
38066 };
38067
38068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38070 if (SWIG_arg_fail(1)) SWIG_fail;
38071 {
38072 PyThreadState* __tstate = wxPyBeginAllowThreads();
38073 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38074
38075 wxPyEndAllowThreads(__tstate);
38076 if (PyErr_Occurred()) SWIG_fail;
38077 }
38078 {
38079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38080 }
38081 return resultobj;
38082 fail:
38083 return NULL;
38084 }
38085
38086
38087 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38088 PyObject *resultobj;
38089 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38090 int arg2 ;
38091 wxString result;
38092 PyObject * obj0 = 0 ;
38093 PyObject * obj1 = 0 ;
38094 char *kwnames[] = {
38095 (char *) "self",(char *) "n", NULL
38096 };
38097
38098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38100 if (SWIG_arg_fail(1)) SWIG_fail;
38101 {
38102 arg2 = (int)(SWIG_As_int(obj1));
38103 if (SWIG_arg_fail(2)) SWIG_fail;
38104 }
38105 {
38106 PyThreadState* __tstate = wxPyBeginAllowThreads();
38107 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38108
38109 wxPyEndAllowThreads(__tstate);
38110 if (PyErr_Occurred()) SWIG_fail;
38111 }
38112 {
38113 #if wxUSE_UNICODE
38114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38115 #else
38116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38117 #endif
38118 }
38119 return resultobj;
38120 fail:
38121 return NULL;
38122 }
38123
38124
38125 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38126 PyObject *resultobj;
38127 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38128 wxArrayString result;
38129 PyObject * obj0 = 0 ;
38130 char *kwnames[] = {
38131 (char *) "self", NULL
38132 };
38133
38134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",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 = ((wxItemContainer const *)arg1)->GetStrings();
38140
38141 wxPyEndAllowThreads(__tstate);
38142 if (PyErr_Occurred()) SWIG_fail;
38143 }
38144 {
38145 resultobj = wxArrayString2PyList_helper(result);
38146 }
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38154 PyObject *resultobj;
38155 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38156 int arg2 ;
38157 wxString *arg3 = 0 ;
38158 bool temp3 = false ;
38159 PyObject * obj0 = 0 ;
38160 PyObject * obj1 = 0 ;
38161 PyObject * obj2 = 0 ;
38162 char *kwnames[] = {
38163 (char *) "self",(char *) "n",(char *) "s", NULL
38164 };
38165
38166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38168 if (SWIG_arg_fail(1)) SWIG_fail;
38169 {
38170 arg2 = (int)(SWIG_As_int(obj1));
38171 if (SWIG_arg_fail(2)) SWIG_fail;
38172 }
38173 {
38174 arg3 = wxString_in_helper(obj2);
38175 if (arg3 == NULL) SWIG_fail;
38176 temp3 = true;
38177 }
38178 {
38179 PyThreadState* __tstate = wxPyBeginAllowThreads();
38180 (arg1)->SetString(arg2,(wxString const &)*arg3);
38181
38182 wxPyEndAllowThreads(__tstate);
38183 if (PyErr_Occurred()) SWIG_fail;
38184 }
38185 Py_INCREF(Py_None); resultobj = Py_None;
38186 {
38187 if (temp3)
38188 delete arg3;
38189 }
38190 return resultobj;
38191 fail:
38192 {
38193 if (temp3)
38194 delete arg3;
38195 }
38196 return NULL;
38197 }
38198
38199
38200 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38201 PyObject *resultobj;
38202 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38203 wxString *arg2 = 0 ;
38204 int result;
38205 bool temp2 = false ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 char *kwnames[] = {
38209 (char *) "self",(char *) "s", NULL
38210 };
38211
38212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38214 if (SWIG_arg_fail(1)) SWIG_fail;
38215 {
38216 arg2 = wxString_in_helper(obj1);
38217 if (arg2 == NULL) SWIG_fail;
38218 temp2 = true;
38219 }
38220 {
38221 PyThreadState* __tstate = wxPyBeginAllowThreads();
38222 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38223
38224 wxPyEndAllowThreads(__tstate);
38225 if (PyErr_Occurred()) SWIG_fail;
38226 }
38227 {
38228 resultobj = SWIG_From_int((int)(result));
38229 }
38230 {
38231 if (temp2)
38232 delete arg2;
38233 }
38234 return resultobj;
38235 fail:
38236 {
38237 if (temp2)
38238 delete arg2;
38239 }
38240 return NULL;
38241 }
38242
38243
38244 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38245 PyObject *resultobj;
38246 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38247 int arg2 ;
38248 PyObject * obj0 = 0 ;
38249 PyObject * obj1 = 0 ;
38250 char *kwnames[] = {
38251 (char *) "self",(char *) "n", NULL
38252 };
38253
38254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38256 if (SWIG_arg_fail(1)) SWIG_fail;
38257 {
38258 arg2 = (int)(SWIG_As_int(obj1));
38259 if (SWIG_arg_fail(2)) SWIG_fail;
38260 }
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 (arg1)->SetSelection(arg2);
38264
38265 wxPyEndAllowThreads(__tstate);
38266 if (PyErr_Occurred()) SWIG_fail;
38267 }
38268 Py_INCREF(Py_None); resultobj = Py_None;
38269 return resultobj;
38270 fail:
38271 return NULL;
38272 }
38273
38274
38275 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38276 PyObject *resultobj;
38277 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38278 int result;
38279 PyObject * obj0 = 0 ;
38280 char *kwnames[] = {
38281 (char *) "self", NULL
38282 };
38283
38284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38286 if (SWIG_arg_fail(1)) SWIG_fail;
38287 {
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38290
38291 wxPyEndAllowThreads(__tstate);
38292 if (PyErr_Occurred()) SWIG_fail;
38293 }
38294 {
38295 resultobj = SWIG_From_int((int)(result));
38296 }
38297 return resultobj;
38298 fail:
38299 return NULL;
38300 }
38301
38302
38303 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj;
38305 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38306 wxString *arg2 = 0 ;
38307 bool result;
38308 bool temp2 = false ;
38309 PyObject * obj0 = 0 ;
38310 PyObject * obj1 = 0 ;
38311 char *kwnames[] = {
38312 (char *) "self",(char *) "s", NULL
38313 };
38314
38315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38317 if (SWIG_arg_fail(1)) SWIG_fail;
38318 {
38319 arg2 = wxString_in_helper(obj1);
38320 if (arg2 == NULL) SWIG_fail;
38321 temp2 = true;
38322 }
38323 {
38324 PyThreadState* __tstate = wxPyBeginAllowThreads();
38325 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38326
38327 wxPyEndAllowThreads(__tstate);
38328 if (PyErr_Occurred()) SWIG_fail;
38329 }
38330 {
38331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38332 }
38333 {
38334 if (temp2)
38335 delete arg2;
38336 }
38337 return resultobj;
38338 fail:
38339 {
38340 if (temp2)
38341 delete arg2;
38342 }
38343 return NULL;
38344 }
38345
38346
38347 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38348 PyObject *resultobj;
38349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38350 wxString result;
38351 PyObject * obj0 = 0 ;
38352 char *kwnames[] = {
38353 (char *) "self", NULL
38354 };
38355
38356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38358 if (SWIG_arg_fail(1)) SWIG_fail;
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38362
38363 wxPyEndAllowThreads(__tstate);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 }
38366 {
38367 #if wxUSE_UNICODE
38368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38369 #else
38370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38371 #endif
38372 }
38373 return resultobj;
38374 fail:
38375 return NULL;
38376 }
38377
38378
38379 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38380 PyObject *resultobj;
38381 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38382 int arg2 ;
38383 PyObject * obj0 = 0 ;
38384 PyObject * obj1 = 0 ;
38385 char *kwnames[] = {
38386 (char *) "self",(char *) "n", NULL
38387 };
38388
38389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38391 if (SWIG_arg_fail(1)) SWIG_fail;
38392 {
38393 arg2 = (int)(SWIG_As_int(obj1));
38394 if (SWIG_arg_fail(2)) SWIG_fail;
38395 }
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 (arg1)->Select(arg2);
38399
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 Py_INCREF(Py_None); resultobj = Py_None;
38404 return resultobj;
38405 fail:
38406 return NULL;
38407 }
38408
38409
38410 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38411 PyObject *obj;
38412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38413 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38414 Py_INCREF(obj);
38415 return Py_BuildValue((char *)"");
38416 }
38417 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38418 PyObject *obj;
38419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38420 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38421 Py_INCREF(obj);
38422 return Py_BuildValue((char *)"");
38423 }
38424 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38425 PyObject *resultobj;
38426 wxSizerItem *result;
38427 char *kwnames[] = {
38428 NULL
38429 };
38430
38431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (wxSizerItem *)new wxSizerItem();
38435
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj;
38448 wxWindow *arg1 = (wxWindow *) 0 ;
38449 int arg2 ;
38450 int arg3 ;
38451 int arg4 ;
38452 PyObject *arg5 = (PyObject *) NULL ;
38453 wxSizerItem *result;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 PyObject * obj2 = 0 ;
38457 PyObject * obj3 = 0 ;
38458 PyObject * obj4 = 0 ;
38459 char *kwnames[] = {
38460 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38461 };
38462
38463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38465 if (SWIG_arg_fail(1)) SWIG_fail;
38466 {
38467 arg2 = (int)(SWIG_As_int(obj1));
38468 if (SWIG_arg_fail(2)) SWIG_fail;
38469 }
38470 {
38471 arg3 = (int)(SWIG_As_int(obj2));
38472 if (SWIG_arg_fail(3)) SWIG_fail;
38473 }
38474 {
38475 arg4 = (int)(SWIG_As_int(obj3));
38476 if (SWIG_arg_fail(4)) SWIG_fail;
38477 }
38478 if (obj4) {
38479 arg5 = obj4;
38480 }
38481 {
38482 PyThreadState* __tstate = wxPyBeginAllowThreads();
38483 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38484
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38496 PyObject *resultobj;
38497 int arg1 ;
38498 int arg2 ;
38499 int arg3 ;
38500 int arg4 ;
38501 int arg5 ;
38502 PyObject *arg6 = (PyObject *) NULL ;
38503 wxSizerItem *result;
38504 PyObject * obj0 = 0 ;
38505 PyObject * obj1 = 0 ;
38506 PyObject * obj2 = 0 ;
38507 PyObject * obj3 = 0 ;
38508 PyObject * obj4 = 0 ;
38509 PyObject * obj5 = 0 ;
38510 char *kwnames[] = {
38511 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38512 };
38513
38514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38515 {
38516 arg1 = (int)(SWIG_As_int(obj0));
38517 if (SWIG_arg_fail(1)) SWIG_fail;
38518 }
38519 {
38520 arg2 = (int)(SWIG_As_int(obj1));
38521 if (SWIG_arg_fail(2)) SWIG_fail;
38522 }
38523 {
38524 arg3 = (int)(SWIG_As_int(obj2));
38525 if (SWIG_arg_fail(3)) SWIG_fail;
38526 }
38527 {
38528 arg4 = (int)(SWIG_As_int(obj3));
38529 if (SWIG_arg_fail(4)) SWIG_fail;
38530 }
38531 {
38532 arg5 = (int)(SWIG_As_int(obj4));
38533 if (SWIG_arg_fail(5)) SWIG_fail;
38534 }
38535 if (obj5) {
38536 arg6 = obj5;
38537 }
38538 {
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38541
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38546 return resultobj;
38547 fail:
38548 return NULL;
38549 }
38550
38551
38552 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38553 PyObject *resultobj;
38554 wxSizer *arg1 = (wxSizer *) 0 ;
38555 int arg2 ;
38556 int arg3 ;
38557 int arg4 ;
38558 PyObject *arg5 = (PyObject *) NULL ;
38559 wxSizerItem *result;
38560 PyObject * obj0 = 0 ;
38561 PyObject * obj1 = 0 ;
38562 PyObject * obj2 = 0 ;
38563 PyObject * obj3 = 0 ;
38564 PyObject * obj4 = 0 ;
38565 char *kwnames[] = {
38566 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38567 };
38568
38569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38571 if (SWIG_arg_fail(1)) SWIG_fail;
38572 {
38573 arg2 = (int)(SWIG_As_int(obj1));
38574 if (SWIG_arg_fail(2)) SWIG_fail;
38575 }
38576 {
38577 arg3 = (int)(SWIG_As_int(obj2));
38578 if (SWIG_arg_fail(3)) SWIG_fail;
38579 }
38580 {
38581 arg4 = (int)(SWIG_As_int(obj3));
38582 if (SWIG_arg_fail(4)) SWIG_fail;
38583 }
38584 if (obj4) {
38585 arg5 = obj4;
38586 }
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38590
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38595 return resultobj;
38596 fail:
38597 return NULL;
38598 }
38599
38600
38601 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38602 PyObject *resultobj;
38603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38604 PyObject * obj0 = 0 ;
38605 char *kwnames[] = {
38606 (char *) "self", NULL
38607 };
38608
38609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38611 if (SWIG_arg_fail(1)) SWIG_fail;
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 (arg1)->DeleteWindows();
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 Py_INCREF(Py_None); resultobj = Py_None;
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38629 PyObject * obj0 = 0 ;
38630 char *kwnames[] = {
38631 (char *) "self", NULL
38632 };
38633
38634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38636 if (SWIG_arg_fail(1)) SWIG_fail;
38637 {
38638 PyThreadState* __tstate = wxPyBeginAllowThreads();
38639 (arg1)->DetachSizer();
38640
38641 wxPyEndAllowThreads(__tstate);
38642 if (PyErr_Occurred()) SWIG_fail;
38643 }
38644 Py_INCREF(Py_None); resultobj = Py_None;
38645 return resultobj;
38646 fail:
38647 return NULL;
38648 }
38649
38650
38651 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38652 PyObject *resultobj;
38653 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38654 wxSize result;
38655 PyObject * obj0 = 0 ;
38656 char *kwnames[] = {
38657 (char *) "self", NULL
38658 };
38659
38660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38662 if (SWIG_arg_fail(1)) SWIG_fail;
38663 {
38664 PyThreadState* __tstate = wxPyBeginAllowThreads();
38665 result = (arg1)->GetSize();
38666
38667 wxPyEndAllowThreads(__tstate);
38668 if (PyErr_Occurred()) SWIG_fail;
38669 }
38670 {
38671 wxSize * resultptr;
38672 resultptr = new wxSize((wxSize &)(result));
38673 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38674 }
38675 return resultobj;
38676 fail:
38677 return NULL;
38678 }
38679
38680
38681 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38682 PyObject *resultobj;
38683 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38684 wxSize result;
38685 PyObject * obj0 = 0 ;
38686 char *kwnames[] = {
38687 (char *) "self", NULL
38688 };
38689
38690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38692 if (SWIG_arg_fail(1)) SWIG_fail;
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 result = (arg1)->CalcMin();
38696
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 {
38701 wxSize * resultptr;
38702 resultptr = new wxSize((wxSize &)(result));
38703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38704 }
38705 return resultobj;
38706 fail:
38707 return NULL;
38708 }
38709
38710
38711 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38712 PyObject *resultobj;
38713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38714 wxPoint arg2 ;
38715 wxSize arg3 ;
38716 PyObject * obj0 = 0 ;
38717 PyObject * obj1 = 0 ;
38718 PyObject * obj2 = 0 ;
38719 char *kwnames[] = {
38720 (char *) "self",(char *) "pos",(char *) "size", NULL
38721 };
38722
38723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38725 if (SWIG_arg_fail(1)) SWIG_fail;
38726 {
38727 wxPoint * argp;
38728 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38729 if (SWIG_arg_fail(2)) SWIG_fail;
38730 if (argp == NULL) {
38731 SWIG_null_ref("wxPoint");
38732 }
38733 if (SWIG_arg_fail(2)) SWIG_fail;
38734 arg2 = *argp;
38735 }
38736 {
38737 wxSize * argp;
38738 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38739 if (SWIG_arg_fail(3)) SWIG_fail;
38740 if (argp == NULL) {
38741 SWIG_null_ref("wxSize");
38742 }
38743 if (SWIG_arg_fail(3)) SWIG_fail;
38744 arg3 = *argp;
38745 }
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 (arg1)->SetDimension(arg2,arg3);
38749
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 Py_INCREF(Py_None); resultobj = Py_None;
38754 return resultobj;
38755 fail:
38756 return NULL;
38757 }
38758
38759
38760 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38761 PyObject *resultobj;
38762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38763 wxSize result;
38764 PyObject * obj0 = 0 ;
38765 char *kwnames[] = {
38766 (char *) "self", NULL
38767 };
38768
38769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38771 if (SWIG_arg_fail(1)) SWIG_fail;
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 result = (arg1)->GetMinSize();
38775
38776 wxPyEndAllowThreads(__tstate);
38777 if (PyErr_Occurred()) SWIG_fail;
38778 }
38779 {
38780 wxSize * resultptr;
38781 resultptr = new wxSize((wxSize &)(result));
38782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38783 }
38784 return resultobj;
38785 fail:
38786 return NULL;
38787 }
38788
38789
38790 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38791 PyObject *resultobj;
38792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38793 wxSize result;
38794 PyObject * obj0 = 0 ;
38795 char *kwnames[] = {
38796 (char *) "self", NULL
38797 };
38798
38799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38801 if (SWIG_arg_fail(1)) SWIG_fail;
38802 {
38803 PyThreadState* __tstate = wxPyBeginAllowThreads();
38804 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38805
38806 wxPyEndAllowThreads(__tstate);
38807 if (PyErr_Occurred()) SWIG_fail;
38808 }
38809 {
38810 wxSize * resultptr;
38811 resultptr = new wxSize((wxSize &)(result));
38812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38813 }
38814 return resultobj;
38815 fail:
38816 return NULL;
38817 }
38818
38819
38820 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38821 PyObject *resultobj;
38822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38823 int arg2 ;
38824 int arg3 ;
38825 PyObject * obj0 = 0 ;
38826 PyObject * obj1 = 0 ;
38827 PyObject * obj2 = 0 ;
38828 char *kwnames[] = {
38829 (char *) "self",(char *) "x",(char *) "y", NULL
38830 };
38831
38832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38834 if (SWIG_arg_fail(1)) SWIG_fail;
38835 {
38836 arg2 = (int)(SWIG_As_int(obj1));
38837 if (SWIG_arg_fail(2)) SWIG_fail;
38838 }
38839 {
38840 arg3 = (int)(SWIG_As_int(obj2));
38841 if (SWIG_arg_fail(3)) SWIG_fail;
38842 }
38843 {
38844 PyThreadState* __tstate = wxPyBeginAllowThreads();
38845 (arg1)->SetInitSize(arg2,arg3);
38846
38847 wxPyEndAllowThreads(__tstate);
38848 if (PyErr_Occurred()) SWIG_fail;
38849 }
38850 Py_INCREF(Py_None); resultobj = Py_None;
38851 return resultobj;
38852 fail:
38853 return NULL;
38854 }
38855
38856
38857 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38858 PyObject *resultobj;
38859 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38860 int arg2 ;
38861 int arg3 ;
38862 PyObject * obj0 = 0 ;
38863 PyObject * obj1 = 0 ;
38864 PyObject * obj2 = 0 ;
38865 char *kwnames[] = {
38866 (char *) "self",(char *) "width",(char *) "height", NULL
38867 };
38868
38869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38871 if (SWIG_arg_fail(1)) SWIG_fail;
38872 {
38873 arg2 = (int)(SWIG_As_int(obj1));
38874 if (SWIG_arg_fail(2)) SWIG_fail;
38875 }
38876 {
38877 arg3 = (int)(SWIG_As_int(obj2));
38878 if (SWIG_arg_fail(3)) SWIG_fail;
38879 }
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 (arg1)->SetRatio(arg2,arg3);
38883
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 Py_INCREF(Py_None); resultobj = Py_None;
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj;
38896 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38897 wxSize *arg2 = 0 ;
38898 wxSize temp2 ;
38899 PyObject * obj0 = 0 ;
38900 PyObject * obj1 = 0 ;
38901 char *kwnames[] = {
38902 (char *) "self",(char *) "size", NULL
38903 };
38904
38905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38907 if (SWIG_arg_fail(1)) SWIG_fail;
38908 {
38909 arg2 = &temp2;
38910 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38911 }
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 (arg1)->SetRatio((wxSize const &)*arg2);
38915
38916 wxPyEndAllowThreads(__tstate);
38917 if (PyErr_Occurred()) SWIG_fail;
38918 }
38919 Py_INCREF(Py_None); resultobj = Py_None;
38920 return resultobj;
38921 fail:
38922 return NULL;
38923 }
38924
38925
38926 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38927 PyObject *resultobj;
38928 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38929 float arg2 ;
38930 PyObject * obj0 = 0 ;
38931 PyObject * obj1 = 0 ;
38932 char *kwnames[] = {
38933 (char *) "self",(char *) "ratio", NULL
38934 };
38935
38936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38938 if (SWIG_arg_fail(1)) SWIG_fail;
38939 {
38940 arg2 = (float)(SWIG_As_float(obj1));
38941 if (SWIG_arg_fail(2)) SWIG_fail;
38942 }
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 (arg1)->SetRatio(arg2);
38946
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 Py_INCREF(Py_None); resultobj = Py_None;
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38958 PyObject *resultobj;
38959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38960 float result;
38961 PyObject * obj0 = 0 ;
38962 char *kwnames[] = {
38963 (char *) "self", NULL
38964 };
38965
38966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38968 if (SWIG_arg_fail(1)) SWIG_fail;
38969 {
38970 PyThreadState* __tstate = wxPyBeginAllowThreads();
38971 result = (float)(arg1)->GetRatio();
38972
38973 wxPyEndAllowThreads(__tstate);
38974 if (PyErr_Occurred()) SWIG_fail;
38975 }
38976 {
38977 resultobj = SWIG_From_float((float)(result));
38978 }
38979 return resultobj;
38980 fail:
38981 return NULL;
38982 }
38983
38984
38985 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38986 PyObject *resultobj;
38987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38988 wxRect result;
38989 PyObject * obj0 = 0 ;
38990 char *kwnames[] = {
38991 (char *) "self", NULL
38992 };
38993
38994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38996 if (SWIG_arg_fail(1)) SWIG_fail;
38997 {
38998 PyThreadState* __tstate = wxPyBeginAllowThreads();
38999 result = (arg1)->GetRect();
39000
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 {
39005 wxRect * resultptr;
39006 resultptr = new wxRect((wxRect &)(result));
39007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39008 }
39009 return resultobj;
39010 fail:
39011 return NULL;
39012 }
39013
39014
39015 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39016 PyObject *resultobj;
39017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39018 bool result;
39019 PyObject * obj0 = 0 ;
39020 char *kwnames[] = {
39021 (char *) "self", NULL
39022 };
39023
39024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39026 if (SWIG_arg_fail(1)) SWIG_fail;
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 result = (bool)(arg1)->IsWindow();
39030
39031 wxPyEndAllowThreads(__tstate);
39032 if (PyErr_Occurred()) SWIG_fail;
39033 }
39034 {
39035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39036 }
39037 return resultobj;
39038 fail:
39039 return NULL;
39040 }
39041
39042
39043 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39044 PyObject *resultobj;
39045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39046 bool result;
39047 PyObject * obj0 = 0 ;
39048 char *kwnames[] = {
39049 (char *) "self", NULL
39050 };
39051
39052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39054 if (SWIG_arg_fail(1)) SWIG_fail;
39055 {
39056 PyThreadState* __tstate = wxPyBeginAllowThreads();
39057 result = (bool)(arg1)->IsSizer();
39058
39059 wxPyEndAllowThreads(__tstate);
39060 if (PyErr_Occurred()) SWIG_fail;
39061 }
39062 {
39063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39064 }
39065 return resultobj;
39066 fail:
39067 return NULL;
39068 }
39069
39070
39071 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj;
39073 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39074 bool result;
39075 PyObject * obj0 = 0 ;
39076 char *kwnames[] = {
39077 (char *) "self", NULL
39078 };
39079
39080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39082 if (SWIG_arg_fail(1)) SWIG_fail;
39083 {
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 result = (bool)(arg1)->IsSpacer();
39086
39087 wxPyEndAllowThreads(__tstate);
39088 if (PyErr_Occurred()) SWIG_fail;
39089 }
39090 {
39091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39092 }
39093 return resultobj;
39094 fail:
39095 return NULL;
39096 }
39097
39098
39099 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39100 PyObject *resultobj;
39101 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39102 int arg2 ;
39103 PyObject * obj0 = 0 ;
39104 PyObject * obj1 = 0 ;
39105 char *kwnames[] = {
39106 (char *) "self",(char *) "proportion", NULL
39107 };
39108
39109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39111 if (SWIG_arg_fail(1)) SWIG_fail;
39112 {
39113 arg2 = (int)(SWIG_As_int(obj1));
39114 if (SWIG_arg_fail(2)) SWIG_fail;
39115 }
39116 {
39117 PyThreadState* __tstate = wxPyBeginAllowThreads();
39118 (arg1)->SetProportion(arg2);
39119
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 Py_INCREF(Py_None); resultobj = Py_None;
39124 return resultobj;
39125 fail:
39126 return NULL;
39127 }
39128
39129
39130 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39131 PyObject *resultobj;
39132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39133 int result;
39134 PyObject * obj0 = 0 ;
39135 char *kwnames[] = {
39136 (char *) "self", NULL
39137 };
39138
39139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39141 if (SWIG_arg_fail(1)) SWIG_fail;
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 result = (int)(arg1)->GetProportion();
39145
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 {
39150 resultobj = SWIG_From_int((int)(result));
39151 }
39152 return resultobj;
39153 fail:
39154 return NULL;
39155 }
39156
39157
39158 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39159 PyObject *resultobj;
39160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39161 int arg2 ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 char *kwnames[] = {
39165 (char *) "self",(char *) "flag", NULL
39166 };
39167
39168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39170 if (SWIG_arg_fail(1)) SWIG_fail;
39171 {
39172 arg2 = (int)(SWIG_As_int(obj1));
39173 if (SWIG_arg_fail(2)) SWIG_fail;
39174 }
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 (arg1)->SetFlag(arg2);
39178
39179 wxPyEndAllowThreads(__tstate);
39180 if (PyErr_Occurred()) SWIG_fail;
39181 }
39182 Py_INCREF(Py_None); resultobj = Py_None;
39183 return resultobj;
39184 fail:
39185 return NULL;
39186 }
39187
39188
39189 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39190 PyObject *resultobj;
39191 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39192 int result;
39193 PyObject * obj0 = 0 ;
39194 char *kwnames[] = {
39195 (char *) "self", NULL
39196 };
39197
39198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39200 if (SWIG_arg_fail(1)) SWIG_fail;
39201 {
39202 PyThreadState* __tstate = wxPyBeginAllowThreads();
39203 result = (int)(arg1)->GetFlag();
39204
39205 wxPyEndAllowThreads(__tstate);
39206 if (PyErr_Occurred()) SWIG_fail;
39207 }
39208 {
39209 resultobj = SWIG_From_int((int)(result));
39210 }
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj;
39219 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39220 int arg2 ;
39221 PyObject * obj0 = 0 ;
39222 PyObject * obj1 = 0 ;
39223 char *kwnames[] = {
39224 (char *) "self",(char *) "border", NULL
39225 };
39226
39227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39229 if (SWIG_arg_fail(1)) SWIG_fail;
39230 {
39231 arg2 = (int)(SWIG_As_int(obj1));
39232 if (SWIG_arg_fail(2)) SWIG_fail;
39233 }
39234 {
39235 PyThreadState* __tstate = wxPyBeginAllowThreads();
39236 (arg1)->SetBorder(arg2);
39237
39238 wxPyEndAllowThreads(__tstate);
39239 if (PyErr_Occurred()) SWIG_fail;
39240 }
39241 Py_INCREF(Py_None); resultobj = Py_None;
39242 return resultobj;
39243 fail:
39244 return NULL;
39245 }
39246
39247
39248 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39249 PyObject *resultobj;
39250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39251 int result;
39252 PyObject * obj0 = 0 ;
39253 char *kwnames[] = {
39254 (char *) "self", NULL
39255 };
39256
39257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39259 if (SWIG_arg_fail(1)) SWIG_fail;
39260 {
39261 PyThreadState* __tstate = wxPyBeginAllowThreads();
39262 result = (int)(arg1)->GetBorder();
39263
39264 wxPyEndAllowThreads(__tstate);
39265 if (PyErr_Occurred()) SWIG_fail;
39266 }
39267 {
39268 resultobj = SWIG_From_int((int)(result));
39269 }
39270 return resultobj;
39271 fail:
39272 return NULL;
39273 }
39274
39275
39276 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39277 PyObject *resultobj;
39278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39279 wxWindow *result;
39280 PyObject * obj0 = 0 ;
39281 char *kwnames[] = {
39282 (char *) "self", NULL
39283 };
39284
39285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39287 if (SWIG_arg_fail(1)) SWIG_fail;
39288 {
39289 PyThreadState* __tstate = wxPyBeginAllowThreads();
39290 result = (wxWindow *)(arg1)->GetWindow();
39291
39292 wxPyEndAllowThreads(__tstate);
39293 if (PyErr_Occurred()) SWIG_fail;
39294 }
39295 {
39296 resultobj = wxPyMake_wxObject(result, 0);
39297 }
39298 return resultobj;
39299 fail:
39300 return NULL;
39301 }
39302
39303
39304 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39305 PyObject *resultobj;
39306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39307 wxWindow *arg2 = (wxWindow *) 0 ;
39308 PyObject * obj0 = 0 ;
39309 PyObject * obj1 = 0 ;
39310 char *kwnames[] = {
39311 (char *) "self",(char *) "window", NULL
39312 };
39313
39314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39316 if (SWIG_arg_fail(1)) SWIG_fail;
39317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39318 if (SWIG_arg_fail(2)) SWIG_fail;
39319 {
39320 PyThreadState* __tstate = wxPyBeginAllowThreads();
39321 (arg1)->SetWindow(arg2);
39322
39323 wxPyEndAllowThreads(__tstate);
39324 if (PyErr_Occurred()) SWIG_fail;
39325 }
39326 Py_INCREF(Py_None); resultobj = Py_None;
39327 return resultobj;
39328 fail:
39329 return NULL;
39330 }
39331
39332
39333 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39334 PyObject *resultobj;
39335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39336 wxSizer *result;
39337 PyObject * obj0 = 0 ;
39338 char *kwnames[] = {
39339 (char *) "self", NULL
39340 };
39341
39342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39344 if (SWIG_arg_fail(1)) SWIG_fail;
39345 {
39346 PyThreadState* __tstate = wxPyBeginAllowThreads();
39347 result = (wxSizer *)(arg1)->GetSizer();
39348
39349 wxPyEndAllowThreads(__tstate);
39350 if (PyErr_Occurred()) SWIG_fail;
39351 }
39352 {
39353 resultobj = wxPyMake_wxSizer(result, 0);
39354 }
39355 return resultobj;
39356 fail:
39357 return NULL;
39358 }
39359
39360
39361 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39362 PyObject *resultobj;
39363 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39364 wxSizer *arg2 = (wxSizer *) 0 ;
39365 PyObject * obj0 = 0 ;
39366 PyObject * obj1 = 0 ;
39367 char *kwnames[] = {
39368 (char *) "self",(char *) "sizer", NULL
39369 };
39370
39371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39373 if (SWIG_arg_fail(1)) SWIG_fail;
39374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39375 if (SWIG_arg_fail(2)) SWIG_fail;
39376 {
39377 PyThreadState* __tstate = wxPyBeginAllowThreads();
39378 (arg1)->SetSizer(arg2);
39379
39380 wxPyEndAllowThreads(__tstate);
39381 if (PyErr_Occurred()) SWIG_fail;
39382 }
39383 Py_INCREF(Py_None); resultobj = Py_None;
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj;
39392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39393 wxSize *result;
39394 PyObject * obj0 = 0 ;
39395 char *kwnames[] = {
39396 (char *) "self", NULL
39397 };
39398
39399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",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 {
39405 wxSize const &_result_ref = (arg1)->GetSpacer();
39406 result = (wxSize *) &_result_ref;
39407 }
39408
39409 wxPyEndAllowThreads(__tstate);
39410 if (PyErr_Occurred()) SWIG_fail;
39411 }
39412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39413 return resultobj;
39414 fail:
39415 return NULL;
39416 }
39417
39418
39419 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj;
39421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39422 wxSize *arg2 = 0 ;
39423 wxSize temp2 ;
39424 PyObject * obj0 = 0 ;
39425 PyObject * obj1 = 0 ;
39426 char *kwnames[] = {
39427 (char *) "self",(char *) "size", NULL
39428 };
39429
39430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39432 if (SWIG_arg_fail(1)) SWIG_fail;
39433 {
39434 arg2 = &temp2;
39435 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39436 }
39437 {
39438 PyThreadState* __tstate = wxPyBeginAllowThreads();
39439 (arg1)->SetSpacer((wxSize const &)*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_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39452 PyObject *resultobj;
39453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39454 bool arg2 ;
39455 PyObject * obj0 = 0 ;
39456 PyObject * obj1 = 0 ;
39457 char *kwnames[] = {
39458 (char *) "self",(char *) "show", NULL
39459 };
39460
39461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39463 if (SWIG_arg_fail(1)) SWIG_fail;
39464 {
39465 arg2 = (bool)(SWIG_As_bool(obj1));
39466 if (SWIG_arg_fail(2)) SWIG_fail;
39467 }
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 (arg1)->Show(arg2);
39471
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 Py_INCREF(Py_None); resultobj = Py_None;
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39483 PyObject *resultobj;
39484 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39485 bool result;
39486 PyObject * obj0 = 0 ;
39487 char *kwnames[] = {
39488 (char *) "self", NULL
39489 };
39490
39491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39493 if (SWIG_arg_fail(1)) SWIG_fail;
39494 {
39495 PyThreadState* __tstate = wxPyBeginAllowThreads();
39496 result = (bool)(arg1)->IsShown();
39497
39498 wxPyEndAllowThreads(__tstate);
39499 if (PyErr_Occurred()) SWIG_fail;
39500 }
39501 {
39502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39503 }
39504 return resultobj;
39505 fail:
39506 return NULL;
39507 }
39508
39509
39510 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39511 PyObject *resultobj;
39512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39513 wxPoint result;
39514 PyObject * obj0 = 0 ;
39515 char *kwnames[] = {
39516 (char *) "self", NULL
39517 };
39518
39519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39521 if (SWIG_arg_fail(1)) SWIG_fail;
39522 {
39523 PyThreadState* __tstate = wxPyBeginAllowThreads();
39524 result = (arg1)->GetPosition();
39525
39526 wxPyEndAllowThreads(__tstate);
39527 if (PyErr_Occurred()) SWIG_fail;
39528 }
39529 {
39530 wxPoint * resultptr;
39531 resultptr = new wxPoint((wxPoint &)(result));
39532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39533 }
39534 return resultobj;
39535 fail:
39536 return NULL;
39537 }
39538
39539
39540 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39541 PyObject *resultobj;
39542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39543 PyObject *result;
39544 PyObject * obj0 = 0 ;
39545 char *kwnames[] = {
39546 (char *) "self", NULL
39547 };
39548
39549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39551 if (SWIG_arg_fail(1)) SWIG_fail;
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39555
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 resultobj = result;
39560 return resultobj;
39561 fail:
39562 return NULL;
39563 }
39564
39565
39566 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39567 PyObject *obj;
39568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39569 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39570 Py_INCREF(obj);
39571 return Py_BuildValue((char *)"");
39572 }
39573 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39574 PyObject *resultobj;
39575 wxSizer *arg1 = (wxSizer *) 0 ;
39576 PyObject *arg2 = (PyObject *) 0 ;
39577 PyObject * obj0 = 0 ;
39578 PyObject * obj1 = 0 ;
39579 char *kwnames[] = {
39580 (char *) "self",(char *) "_self", NULL
39581 };
39582
39583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39585 if (SWIG_arg_fail(1)) SWIG_fail;
39586 arg2 = obj1;
39587 {
39588 PyThreadState* __tstate = wxPyBeginAllowThreads();
39589 wxSizer__setOORInfo(arg1,arg2);
39590
39591 wxPyEndAllowThreads(__tstate);
39592 if (PyErr_Occurred()) SWIG_fail;
39593 }
39594 Py_INCREF(Py_None); resultobj = Py_None;
39595 return resultobj;
39596 fail:
39597 return NULL;
39598 }
39599
39600
39601 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39602 PyObject *resultobj;
39603 wxSizer *arg1 = (wxSizer *) 0 ;
39604 PyObject *arg2 = (PyObject *) 0 ;
39605 int arg3 = (int) 0 ;
39606 int arg4 = (int) 0 ;
39607 int arg5 = (int) 0 ;
39608 PyObject *arg6 = (PyObject *) NULL ;
39609 wxSizerItem *result;
39610 PyObject * obj0 = 0 ;
39611 PyObject * obj1 = 0 ;
39612 PyObject * obj2 = 0 ;
39613 PyObject * obj3 = 0 ;
39614 PyObject * obj4 = 0 ;
39615 PyObject * obj5 = 0 ;
39616 char *kwnames[] = {
39617 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39618 };
39619
39620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39622 if (SWIG_arg_fail(1)) SWIG_fail;
39623 arg2 = obj1;
39624 if (obj2) {
39625 {
39626 arg3 = (int)(SWIG_As_int(obj2));
39627 if (SWIG_arg_fail(3)) SWIG_fail;
39628 }
39629 }
39630 if (obj3) {
39631 {
39632 arg4 = (int)(SWIG_As_int(obj3));
39633 if (SWIG_arg_fail(4)) SWIG_fail;
39634 }
39635 }
39636 if (obj4) {
39637 {
39638 arg5 = (int)(SWIG_As_int(obj4));
39639 if (SWIG_arg_fail(5)) SWIG_fail;
39640 }
39641 }
39642 if (obj5) {
39643 arg6 = obj5;
39644 }
39645 {
39646 PyThreadState* __tstate = wxPyBeginAllowThreads();
39647 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39648
39649 wxPyEndAllowThreads(__tstate);
39650 if (PyErr_Occurred()) SWIG_fail;
39651 }
39652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39653 return resultobj;
39654 fail:
39655 return NULL;
39656 }
39657
39658
39659 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39660 PyObject *resultobj;
39661 wxSizer *arg1 = (wxSizer *) 0 ;
39662 int arg2 ;
39663 PyObject *arg3 = (PyObject *) 0 ;
39664 int arg4 = (int) 0 ;
39665 int arg5 = (int) 0 ;
39666 int arg6 = (int) 0 ;
39667 PyObject *arg7 = (PyObject *) NULL ;
39668 wxSizerItem *result;
39669 PyObject * obj0 = 0 ;
39670 PyObject * obj1 = 0 ;
39671 PyObject * obj2 = 0 ;
39672 PyObject * obj3 = 0 ;
39673 PyObject * obj4 = 0 ;
39674 PyObject * obj5 = 0 ;
39675 PyObject * obj6 = 0 ;
39676 char *kwnames[] = {
39677 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39678 };
39679
39680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39682 if (SWIG_arg_fail(1)) SWIG_fail;
39683 {
39684 arg2 = (int)(SWIG_As_int(obj1));
39685 if (SWIG_arg_fail(2)) SWIG_fail;
39686 }
39687 arg3 = obj2;
39688 if (obj3) {
39689 {
39690 arg4 = (int)(SWIG_As_int(obj3));
39691 if (SWIG_arg_fail(4)) SWIG_fail;
39692 }
39693 }
39694 if (obj4) {
39695 {
39696 arg5 = (int)(SWIG_As_int(obj4));
39697 if (SWIG_arg_fail(5)) SWIG_fail;
39698 }
39699 }
39700 if (obj5) {
39701 {
39702 arg6 = (int)(SWIG_As_int(obj5));
39703 if (SWIG_arg_fail(6)) SWIG_fail;
39704 }
39705 }
39706 if (obj6) {
39707 arg7 = obj6;
39708 }
39709 {
39710 PyThreadState* __tstate = wxPyBeginAllowThreads();
39711 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39712
39713 wxPyEndAllowThreads(__tstate);
39714 if (PyErr_Occurred()) SWIG_fail;
39715 }
39716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39717 return resultobj;
39718 fail:
39719 return NULL;
39720 }
39721
39722
39723 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39724 PyObject *resultobj;
39725 wxSizer *arg1 = (wxSizer *) 0 ;
39726 PyObject *arg2 = (PyObject *) 0 ;
39727 int arg3 = (int) 0 ;
39728 int arg4 = (int) 0 ;
39729 int arg5 = (int) 0 ;
39730 PyObject *arg6 = (PyObject *) NULL ;
39731 wxSizerItem *result;
39732 PyObject * obj0 = 0 ;
39733 PyObject * obj1 = 0 ;
39734 PyObject * obj2 = 0 ;
39735 PyObject * obj3 = 0 ;
39736 PyObject * obj4 = 0 ;
39737 PyObject * obj5 = 0 ;
39738 char *kwnames[] = {
39739 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39740 };
39741
39742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39744 if (SWIG_arg_fail(1)) SWIG_fail;
39745 arg2 = obj1;
39746 if (obj2) {
39747 {
39748 arg3 = (int)(SWIG_As_int(obj2));
39749 if (SWIG_arg_fail(3)) SWIG_fail;
39750 }
39751 }
39752 if (obj3) {
39753 {
39754 arg4 = (int)(SWIG_As_int(obj3));
39755 if (SWIG_arg_fail(4)) SWIG_fail;
39756 }
39757 }
39758 if (obj4) {
39759 {
39760 arg5 = (int)(SWIG_As_int(obj4));
39761 if (SWIG_arg_fail(5)) SWIG_fail;
39762 }
39763 }
39764 if (obj5) {
39765 arg6 = obj5;
39766 }
39767 {
39768 PyThreadState* __tstate = wxPyBeginAllowThreads();
39769 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39770
39771 wxPyEndAllowThreads(__tstate);
39772 if (PyErr_Occurred()) SWIG_fail;
39773 }
39774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39775 return resultobj;
39776 fail:
39777 return NULL;
39778 }
39779
39780
39781 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39782 PyObject *resultobj;
39783 wxSizer *arg1 = (wxSizer *) 0 ;
39784 PyObject *arg2 = (PyObject *) 0 ;
39785 bool result;
39786 PyObject * obj0 = 0 ;
39787 PyObject * obj1 = 0 ;
39788 char *kwnames[] = {
39789 (char *) "self",(char *) "item", NULL
39790 };
39791
39792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39794 if (SWIG_arg_fail(1)) SWIG_fail;
39795 arg2 = obj1;
39796 {
39797 PyThreadState* __tstate = wxPyBeginAllowThreads();
39798 result = (bool)wxSizer_Remove(arg1,arg2);
39799
39800 wxPyEndAllowThreads(__tstate);
39801 if (PyErr_Occurred()) SWIG_fail;
39802 }
39803 {
39804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39805 }
39806 return resultobj;
39807 fail:
39808 return NULL;
39809 }
39810
39811
39812 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39813 PyObject *resultobj;
39814 wxSizer *arg1 = (wxSizer *) 0 ;
39815 PyObject *arg2 = (PyObject *) 0 ;
39816 bool result;
39817 PyObject * obj0 = 0 ;
39818 PyObject * obj1 = 0 ;
39819 char *kwnames[] = {
39820 (char *) "self",(char *) "item", NULL
39821 };
39822
39823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39825 if (SWIG_arg_fail(1)) SWIG_fail;
39826 arg2 = obj1;
39827 {
39828 PyThreadState* __tstate = wxPyBeginAllowThreads();
39829 result = (bool)wxSizer_Detach(arg1,arg2);
39830
39831 wxPyEndAllowThreads(__tstate);
39832 if (PyErr_Occurred()) SWIG_fail;
39833 }
39834 {
39835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39836 }
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj;
39845 wxSizer *arg1 = (wxSizer *) 0 ;
39846 PyObject *arg2 = (PyObject *) 0 ;
39847 wxSizerItem *result;
39848 PyObject * obj0 = 0 ;
39849 PyObject * obj1 = 0 ;
39850 char *kwnames[] = {
39851 (char *) "self",(char *) "item", NULL
39852 };
39853
39854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39856 if (SWIG_arg_fail(1)) SWIG_fail;
39857 arg2 = obj1;
39858 {
39859 PyThreadState* __tstate = wxPyBeginAllowThreads();
39860 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39861
39862 wxPyEndAllowThreads(__tstate);
39863 if (PyErr_Occurred()) SWIG_fail;
39864 }
39865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39866 return resultobj;
39867 fail:
39868 return NULL;
39869 }
39870
39871
39872 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39873 PyObject *resultobj;
39874 wxSizer *arg1 = (wxSizer *) 0 ;
39875 PyObject *arg2 = (PyObject *) 0 ;
39876 wxSize *arg3 = 0 ;
39877 wxSize temp3 ;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 PyObject * obj2 = 0 ;
39881 char *kwnames[] = {
39882 (char *) "self",(char *) "item",(char *) "size", NULL
39883 };
39884
39885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39887 if (SWIG_arg_fail(1)) SWIG_fail;
39888 arg2 = obj1;
39889 {
39890 arg3 = &temp3;
39891 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39892 }
39893 {
39894 PyThreadState* __tstate = wxPyBeginAllowThreads();
39895 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39896
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 Py_INCREF(Py_None); resultobj = Py_None;
39901 return resultobj;
39902 fail:
39903 return NULL;
39904 }
39905
39906
39907 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj;
39909 wxSizer *arg1 = (wxSizer *) 0 ;
39910 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39911 wxSizerItem *result;
39912 PyObject * obj0 = 0 ;
39913 PyObject * obj1 = 0 ;
39914 char *kwnames[] = {
39915 (char *) "self",(char *) "item", NULL
39916 };
39917
39918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39920 if (SWIG_arg_fail(1)) SWIG_fail;
39921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39922 if (SWIG_arg_fail(2)) SWIG_fail;
39923 {
39924 PyThreadState* __tstate = wxPyBeginAllowThreads();
39925 result = (wxSizerItem *)(arg1)->Add(arg2);
39926
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj;
39939 wxSizer *arg1 = (wxSizer *) 0 ;
39940 size_t arg2 ;
39941 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39942 wxSizerItem *result;
39943 PyObject * obj0 = 0 ;
39944 PyObject * obj1 = 0 ;
39945 PyObject * obj2 = 0 ;
39946 char *kwnames[] = {
39947 (char *) "self",(char *) "index",(char *) "item", NULL
39948 };
39949
39950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39952 if (SWIG_arg_fail(1)) SWIG_fail;
39953 {
39954 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39955 if (SWIG_arg_fail(2)) SWIG_fail;
39956 }
39957 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39958 if (SWIG_arg_fail(3)) SWIG_fail;
39959 {
39960 PyThreadState* __tstate = wxPyBeginAllowThreads();
39961 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39962
39963 wxPyEndAllowThreads(__tstate);
39964 if (PyErr_Occurred()) SWIG_fail;
39965 }
39966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39967 return resultobj;
39968 fail:
39969 return NULL;
39970 }
39971
39972
39973 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39974 PyObject *resultobj;
39975 wxSizer *arg1 = (wxSizer *) 0 ;
39976 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39977 wxSizerItem *result;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 char *kwnames[] = {
39981 (char *) "self",(char *) "item", NULL
39982 };
39983
39984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39986 if (SWIG_arg_fail(1)) SWIG_fail;
39987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39988 if (SWIG_arg_fail(2)) SWIG_fail;
39989 {
39990 PyThreadState* __tstate = wxPyBeginAllowThreads();
39991 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39992
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39997 return resultobj;
39998 fail:
39999 return NULL;
40000 }
40001
40002
40003 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40004 PyObject *resultobj;
40005 wxSizer *arg1 = (wxSizer *) 0 ;
40006 int arg2 ;
40007 int arg3 ;
40008 int arg4 ;
40009 int arg5 ;
40010 PyObject * obj0 = 0 ;
40011 PyObject * obj1 = 0 ;
40012 PyObject * obj2 = 0 ;
40013 PyObject * obj3 = 0 ;
40014 PyObject * obj4 = 0 ;
40015 char *kwnames[] = {
40016 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40017 };
40018
40019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40021 if (SWIG_arg_fail(1)) SWIG_fail;
40022 {
40023 arg2 = (int)(SWIG_As_int(obj1));
40024 if (SWIG_arg_fail(2)) SWIG_fail;
40025 }
40026 {
40027 arg3 = (int)(SWIG_As_int(obj2));
40028 if (SWIG_arg_fail(3)) SWIG_fail;
40029 }
40030 {
40031 arg4 = (int)(SWIG_As_int(obj3));
40032 if (SWIG_arg_fail(4)) SWIG_fail;
40033 }
40034 {
40035 arg5 = (int)(SWIG_As_int(obj4));
40036 if (SWIG_arg_fail(5)) SWIG_fail;
40037 }
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40041
40042 wxPyEndAllowThreads(__tstate);
40043 if (PyErr_Occurred()) SWIG_fail;
40044 }
40045 Py_INCREF(Py_None); resultobj = Py_None;
40046 return resultobj;
40047 fail:
40048 return NULL;
40049 }
40050
40051
40052 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40053 PyObject *resultobj;
40054 wxSizer *arg1 = (wxSizer *) 0 ;
40055 wxSize *arg2 = 0 ;
40056 wxSize temp2 ;
40057 PyObject * obj0 = 0 ;
40058 PyObject * obj1 = 0 ;
40059 char *kwnames[] = {
40060 (char *) "self",(char *) "size", NULL
40061 };
40062
40063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40065 if (SWIG_arg_fail(1)) SWIG_fail;
40066 {
40067 arg2 = &temp2;
40068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40069 }
40070 {
40071 PyThreadState* __tstate = wxPyBeginAllowThreads();
40072 (arg1)->SetMinSize((wxSize const &)*arg2);
40073
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 Py_INCREF(Py_None); resultobj = Py_None;
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj;
40086 wxSizer *arg1 = (wxSizer *) 0 ;
40087 wxSize result;
40088 PyObject * obj0 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40095 if (SWIG_arg_fail(1)) SWIG_fail;
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 result = (arg1)->GetSize();
40099
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 wxSize * resultptr;
40105 resultptr = new wxSize((wxSize &)(result));
40106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40107 }
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40115 PyObject *resultobj;
40116 wxSizer *arg1 = (wxSizer *) 0 ;
40117 wxPoint result;
40118 PyObject * obj0 = 0 ;
40119 char *kwnames[] = {
40120 (char *) "self", NULL
40121 };
40122
40123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40125 if (SWIG_arg_fail(1)) SWIG_fail;
40126 {
40127 PyThreadState* __tstate = wxPyBeginAllowThreads();
40128 result = (arg1)->GetPosition();
40129
40130 wxPyEndAllowThreads(__tstate);
40131 if (PyErr_Occurred()) SWIG_fail;
40132 }
40133 {
40134 wxPoint * resultptr;
40135 resultptr = new wxPoint((wxPoint &)(result));
40136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40137 }
40138 return resultobj;
40139 fail:
40140 return NULL;
40141 }
40142
40143
40144 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj;
40146 wxSizer *arg1 = (wxSizer *) 0 ;
40147 wxSize result;
40148 PyObject * obj0 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40155 if (SWIG_arg_fail(1)) SWIG_fail;
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (arg1)->GetMinSize();
40159
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 {
40164 wxSize * resultptr;
40165 resultptr = new wxSize((wxSize &)(result));
40166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40167 }
40168 return resultobj;
40169 fail:
40170 return NULL;
40171 }
40172
40173
40174 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40175 PyObject *resultobj;
40176 wxSizer *arg1 = (wxSizer *) 0 ;
40177 PyObject * obj0 = 0 ;
40178 char *kwnames[] = {
40179 (char *) "self", NULL
40180 };
40181
40182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40184 if (SWIG_arg_fail(1)) SWIG_fail;
40185 {
40186 PyThreadState* __tstate = wxPyBeginAllowThreads();
40187 (arg1)->RecalcSizes();
40188
40189 wxPyEndAllowThreads(__tstate);
40190 if (PyErr_Occurred()) SWIG_fail;
40191 }
40192 Py_INCREF(Py_None); resultobj = Py_None;
40193 return resultobj;
40194 fail:
40195 return NULL;
40196 }
40197
40198
40199 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40200 PyObject *resultobj;
40201 wxSizer *arg1 = (wxSizer *) 0 ;
40202 wxSize result;
40203 PyObject * obj0 = 0 ;
40204 char *kwnames[] = {
40205 (char *) "self", NULL
40206 };
40207
40208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40210 if (SWIG_arg_fail(1)) SWIG_fail;
40211 {
40212 PyThreadState* __tstate = wxPyBeginAllowThreads();
40213 result = (arg1)->CalcMin();
40214
40215 wxPyEndAllowThreads(__tstate);
40216 if (PyErr_Occurred()) SWIG_fail;
40217 }
40218 {
40219 wxSize * resultptr;
40220 resultptr = new wxSize((wxSize &)(result));
40221 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40222 }
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj;
40231 wxSizer *arg1 = (wxSizer *) 0 ;
40232 PyObject * obj0 = 0 ;
40233 char *kwnames[] = {
40234 (char *) "self", NULL
40235 };
40236
40237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40239 if (SWIG_arg_fail(1)) SWIG_fail;
40240 {
40241 PyThreadState* __tstate = wxPyBeginAllowThreads();
40242 (arg1)->Layout();
40243
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 Py_INCREF(Py_None); resultobj = Py_None;
40248 return resultobj;
40249 fail:
40250 return NULL;
40251 }
40252
40253
40254 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40255 PyObject *resultobj;
40256 wxSizer *arg1 = (wxSizer *) 0 ;
40257 wxWindow *arg2 = (wxWindow *) 0 ;
40258 wxSize result;
40259 PyObject * obj0 = 0 ;
40260 PyObject * obj1 = 0 ;
40261 char *kwnames[] = {
40262 (char *) "self",(char *) "window", NULL
40263 };
40264
40265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40267 if (SWIG_arg_fail(1)) SWIG_fail;
40268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40269 if (SWIG_arg_fail(2)) SWIG_fail;
40270 {
40271 PyThreadState* __tstate = wxPyBeginAllowThreads();
40272 result = (arg1)->Fit(arg2);
40273
40274 wxPyEndAllowThreads(__tstate);
40275 if (PyErr_Occurred()) SWIG_fail;
40276 }
40277 {
40278 wxSize * resultptr;
40279 resultptr = new wxSize((wxSize &)(result));
40280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40281 }
40282 return resultobj;
40283 fail:
40284 return NULL;
40285 }
40286
40287
40288 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40289 PyObject *resultobj;
40290 wxSizer *arg1 = (wxSizer *) 0 ;
40291 wxWindow *arg2 = (wxWindow *) 0 ;
40292 PyObject * obj0 = 0 ;
40293 PyObject * obj1 = 0 ;
40294 char *kwnames[] = {
40295 (char *) "self",(char *) "window", NULL
40296 };
40297
40298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40300 if (SWIG_arg_fail(1)) SWIG_fail;
40301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40302 if (SWIG_arg_fail(2)) SWIG_fail;
40303 {
40304 PyThreadState* __tstate = wxPyBeginAllowThreads();
40305 (arg1)->FitInside(arg2);
40306
40307 wxPyEndAllowThreads(__tstate);
40308 if (PyErr_Occurred()) SWIG_fail;
40309 }
40310 Py_INCREF(Py_None); resultobj = Py_None;
40311 return resultobj;
40312 fail:
40313 return NULL;
40314 }
40315
40316
40317 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40318 PyObject *resultobj;
40319 wxSizer *arg1 = (wxSizer *) 0 ;
40320 wxWindow *arg2 = (wxWindow *) 0 ;
40321 PyObject * obj0 = 0 ;
40322 PyObject * obj1 = 0 ;
40323 char *kwnames[] = {
40324 (char *) "self",(char *) "window", NULL
40325 };
40326
40327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40329 if (SWIG_arg_fail(1)) SWIG_fail;
40330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40331 if (SWIG_arg_fail(2)) SWIG_fail;
40332 {
40333 PyThreadState* __tstate = wxPyBeginAllowThreads();
40334 (arg1)->SetSizeHints(arg2);
40335
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 Py_INCREF(Py_None); resultobj = Py_None;
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40347 PyObject *resultobj;
40348 wxSizer *arg1 = (wxSizer *) 0 ;
40349 wxWindow *arg2 = (wxWindow *) 0 ;
40350 PyObject * obj0 = 0 ;
40351 PyObject * obj1 = 0 ;
40352 char *kwnames[] = {
40353 (char *) "self",(char *) "window", NULL
40354 };
40355
40356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40358 if (SWIG_arg_fail(1)) SWIG_fail;
40359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40360 if (SWIG_arg_fail(2)) SWIG_fail;
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 (arg1)->SetVirtualSizeHints(arg2);
40364
40365 wxPyEndAllowThreads(__tstate);
40366 if (PyErr_Occurred()) SWIG_fail;
40367 }
40368 Py_INCREF(Py_None); resultobj = Py_None;
40369 return resultobj;
40370 fail:
40371 return NULL;
40372 }
40373
40374
40375 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40376 PyObject *resultobj;
40377 wxSizer *arg1 = (wxSizer *) 0 ;
40378 bool arg2 = (bool) false ;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self",(char *) "deleteWindows", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 if (obj1) {
40389 {
40390 arg2 = (bool)(SWIG_As_bool(obj1));
40391 if (SWIG_arg_fail(2)) SWIG_fail;
40392 }
40393 }
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 (arg1)->Clear(arg2);
40397
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 Py_INCREF(Py_None); resultobj = Py_None;
40402 return resultobj;
40403 fail:
40404 return NULL;
40405 }
40406
40407
40408 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40409 PyObject *resultobj;
40410 wxSizer *arg1 = (wxSizer *) 0 ;
40411 PyObject * obj0 = 0 ;
40412 char *kwnames[] = {
40413 (char *) "self", NULL
40414 };
40415
40416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40418 if (SWIG_arg_fail(1)) SWIG_fail;
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 (arg1)->DeleteWindows();
40422
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 Py_INCREF(Py_None); resultobj = Py_None;
40427 return resultobj;
40428 fail:
40429 return NULL;
40430 }
40431
40432
40433 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40434 PyObject *resultobj;
40435 wxSizer *arg1 = (wxSizer *) 0 ;
40436 PyObject *result;
40437 PyObject * obj0 = 0 ;
40438 char *kwnames[] = {
40439 (char *) "self", NULL
40440 };
40441
40442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40444 if (SWIG_arg_fail(1)) SWIG_fail;
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 result = (PyObject *)wxSizer_GetChildren(arg1);
40448
40449 wxPyEndAllowThreads(__tstate);
40450 if (PyErr_Occurred()) SWIG_fail;
40451 }
40452 resultobj = result;
40453 return resultobj;
40454 fail:
40455 return NULL;
40456 }
40457
40458
40459 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40460 PyObject *resultobj;
40461 wxSizer *arg1 = (wxSizer *) 0 ;
40462 PyObject *arg2 = (PyObject *) 0 ;
40463 bool arg3 = (bool) true ;
40464 bool arg4 = (bool) false ;
40465 bool result;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 PyObject * obj2 = 0 ;
40469 PyObject * obj3 = 0 ;
40470 char *kwnames[] = {
40471 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40472 };
40473
40474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40476 if (SWIG_arg_fail(1)) SWIG_fail;
40477 arg2 = obj1;
40478 if (obj2) {
40479 {
40480 arg3 = (bool)(SWIG_As_bool(obj2));
40481 if (SWIG_arg_fail(3)) SWIG_fail;
40482 }
40483 }
40484 if (obj3) {
40485 {
40486 arg4 = (bool)(SWIG_As_bool(obj3));
40487 if (SWIG_arg_fail(4)) SWIG_fail;
40488 }
40489 }
40490 {
40491 PyThreadState* __tstate = wxPyBeginAllowThreads();
40492 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40493
40494 wxPyEndAllowThreads(__tstate);
40495 if (PyErr_Occurred()) SWIG_fail;
40496 }
40497 {
40498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40499 }
40500 return resultobj;
40501 fail:
40502 return NULL;
40503 }
40504
40505
40506 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40507 PyObject *resultobj;
40508 wxSizer *arg1 = (wxSizer *) 0 ;
40509 PyObject *arg2 = (PyObject *) 0 ;
40510 bool result;
40511 PyObject * obj0 = 0 ;
40512 PyObject * obj1 = 0 ;
40513 char *kwnames[] = {
40514 (char *) "self",(char *) "item", NULL
40515 };
40516
40517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40519 if (SWIG_arg_fail(1)) SWIG_fail;
40520 arg2 = obj1;
40521 {
40522 PyThreadState* __tstate = wxPyBeginAllowThreads();
40523 result = (bool)wxSizer_IsShown(arg1,arg2);
40524
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 {
40529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40530 }
40531 return resultobj;
40532 fail:
40533 return NULL;
40534 }
40535
40536
40537 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40538 PyObject *resultobj;
40539 wxSizer *arg1 = (wxSizer *) 0 ;
40540 bool arg2 ;
40541 PyObject * obj0 = 0 ;
40542 PyObject * obj1 = 0 ;
40543 char *kwnames[] = {
40544 (char *) "self",(char *) "show", NULL
40545 };
40546
40547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40549 if (SWIG_arg_fail(1)) SWIG_fail;
40550 {
40551 arg2 = (bool)(SWIG_As_bool(obj1));
40552 if (SWIG_arg_fail(2)) SWIG_fail;
40553 }
40554 {
40555 PyThreadState* __tstate = wxPyBeginAllowThreads();
40556 (arg1)->ShowItems(arg2);
40557
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 Py_INCREF(Py_None); resultobj = Py_None;
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40569 PyObject *obj;
40570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40571 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40572 Py_INCREF(obj);
40573 return Py_BuildValue((char *)"");
40574 }
40575 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40576 PyObject *resultobj;
40577 wxPySizer *result;
40578 char *kwnames[] = {
40579 NULL
40580 };
40581
40582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40583 {
40584 PyThreadState* __tstate = wxPyBeginAllowThreads();
40585 result = (wxPySizer *)new wxPySizer();
40586
40587 wxPyEndAllowThreads(__tstate);
40588 if (PyErr_Occurred()) SWIG_fail;
40589 }
40590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40591 return resultobj;
40592 fail:
40593 return NULL;
40594 }
40595
40596
40597 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40598 PyObject *resultobj;
40599 wxPySizer *arg1 = (wxPySizer *) 0 ;
40600 PyObject *arg2 = (PyObject *) 0 ;
40601 PyObject *arg3 = (PyObject *) 0 ;
40602 PyObject * obj0 = 0 ;
40603 PyObject * obj1 = 0 ;
40604 PyObject * obj2 = 0 ;
40605 char *kwnames[] = {
40606 (char *) "self",(char *) "self",(char *) "_class", NULL
40607 };
40608
40609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40611 if (SWIG_arg_fail(1)) SWIG_fail;
40612 arg2 = obj1;
40613 arg3 = obj2;
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 (arg1)->_setCallbackInfo(arg2,arg3);
40617
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 Py_INCREF(Py_None); resultobj = Py_None;
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40629 PyObject *obj;
40630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40631 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40632 Py_INCREF(obj);
40633 return Py_BuildValue((char *)"");
40634 }
40635 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40636 PyObject *resultobj;
40637 int arg1 = (int) wxHORIZONTAL ;
40638 wxBoxSizer *result;
40639 PyObject * obj0 = 0 ;
40640 char *kwnames[] = {
40641 (char *) "orient", NULL
40642 };
40643
40644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40645 if (obj0) {
40646 {
40647 arg1 = (int)(SWIG_As_int(obj0));
40648 if (SWIG_arg_fail(1)) SWIG_fail;
40649 }
40650 }
40651 {
40652 PyThreadState* __tstate = wxPyBeginAllowThreads();
40653 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40654
40655 wxPyEndAllowThreads(__tstate);
40656 if (PyErr_Occurred()) SWIG_fail;
40657 }
40658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40659 return resultobj;
40660 fail:
40661 return NULL;
40662 }
40663
40664
40665 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40666 PyObject *resultobj;
40667 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40668 int result;
40669 PyObject * obj0 = 0 ;
40670 char *kwnames[] = {
40671 (char *) "self", NULL
40672 };
40673
40674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40676 if (SWIG_arg_fail(1)) SWIG_fail;
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 result = (int)(arg1)->GetOrientation();
40680
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 {
40685 resultobj = SWIG_From_int((int)(result));
40686 }
40687 return resultobj;
40688 fail:
40689 return NULL;
40690 }
40691
40692
40693 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40694 PyObject *resultobj;
40695 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40696 int arg2 ;
40697 PyObject * obj0 = 0 ;
40698 PyObject * obj1 = 0 ;
40699 char *kwnames[] = {
40700 (char *) "self",(char *) "orient", NULL
40701 };
40702
40703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40705 if (SWIG_arg_fail(1)) SWIG_fail;
40706 {
40707 arg2 = (int)(SWIG_As_int(obj1));
40708 if (SWIG_arg_fail(2)) SWIG_fail;
40709 }
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 (arg1)->SetOrientation(arg2);
40713
40714 wxPyEndAllowThreads(__tstate);
40715 if (PyErr_Occurred()) SWIG_fail;
40716 }
40717 Py_INCREF(Py_None); resultobj = Py_None;
40718 return resultobj;
40719 fail:
40720 return NULL;
40721 }
40722
40723
40724 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40725 PyObject *obj;
40726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40727 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40728 Py_INCREF(obj);
40729 return Py_BuildValue((char *)"");
40730 }
40731 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40732 PyObject *resultobj;
40733 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40734 int arg2 = (int) wxHORIZONTAL ;
40735 wxStaticBoxSizer *result;
40736 PyObject * obj0 = 0 ;
40737 PyObject * obj1 = 0 ;
40738 char *kwnames[] = {
40739 (char *) "box",(char *) "orient", NULL
40740 };
40741
40742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40744 if (SWIG_arg_fail(1)) SWIG_fail;
40745 if (obj1) {
40746 {
40747 arg2 = (int)(SWIG_As_int(obj1));
40748 if (SWIG_arg_fail(2)) SWIG_fail;
40749 }
40750 }
40751 {
40752 PyThreadState* __tstate = wxPyBeginAllowThreads();
40753 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40754
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40766 PyObject *resultobj;
40767 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40768 wxStaticBox *result;
40769 PyObject * obj0 = 0 ;
40770 char *kwnames[] = {
40771 (char *) "self", NULL
40772 };
40773
40774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40776 if (SWIG_arg_fail(1)) SWIG_fail;
40777 {
40778 PyThreadState* __tstate = wxPyBeginAllowThreads();
40779 result = (wxStaticBox *)(arg1)->GetStaticBox();
40780
40781 wxPyEndAllowThreads(__tstate);
40782 if (PyErr_Occurred()) SWIG_fail;
40783 }
40784 {
40785 resultobj = wxPyMake_wxObject(result, 0);
40786 }
40787 return resultobj;
40788 fail:
40789 return NULL;
40790 }
40791
40792
40793 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40794 PyObject *obj;
40795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40796 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40797 Py_INCREF(obj);
40798 return Py_BuildValue((char *)"");
40799 }
40800 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40801 PyObject *resultobj;
40802 int arg1 = (int) 1 ;
40803 int arg2 = (int) 0 ;
40804 int arg3 = (int) 0 ;
40805 int arg4 = (int) 0 ;
40806 wxGridSizer *result;
40807 PyObject * obj0 = 0 ;
40808 PyObject * obj1 = 0 ;
40809 PyObject * obj2 = 0 ;
40810 PyObject * obj3 = 0 ;
40811 char *kwnames[] = {
40812 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40813 };
40814
40815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40816 if (obj0) {
40817 {
40818 arg1 = (int)(SWIG_As_int(obj0));
40819 if (SWIG_arg_fail(1)) SWIG_fail;
40820 }
40821 }
40822 if (obj1) {
40823 {
40824 arg2 = (int)(SWIG_As_int(obj1));
40825 if (SWIG_arg_fail(2)) SWIG_fail;
40826 }
40827 }
40828 if (obj2) {
40829 {
40830 arg3 = (int)(SWIG_As_int(obj2));
40831 if (SWIG_arg_fail(3)) SWIG_fail;
40832 }
40833 }
40834 if (obj3) {
40835 {
40836 arg4 = (int)(SWIG_As_int(obj3));
40837 if (SWIG_arg_fail(4)) SWIG_fail;
40838 }
40839 }
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40843
40844 wxPyEndAllowThreads(__tstate);
40845 if (PyErr_Occurred()) SWIG_fail;
40846 }
40847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40848 return resultobj;
40849 fail:
40850 return NULL;
40851 }
40852
40853
40854 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40855 PyObject *resultobj;
40856 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40857 int arg2 ;
40858 PyObject * obj0 = 0 ;
40859 PyObject * obj1 = 0 ;
40860 char *kwnames[] = {
40861 (char *) "self",(char *) "cols", NULL
40862 };
40863
40864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40866 if (SWIG_arg_fail(1)) SWIG_fail;
40867 {
40868 arg2 = (int)(SWIG_As_int(obj1));
40869 if (SWIG_arg_fail(2)) SWIG_fail;
40870 }
40871 {
40872 PyThreadState* __tstate = wxPyBeginAllowThreads();
40873 (arg1)->SetCols(arg2);
40874
40875 wxPyEndAllowThreads(__tstate);
40876 if (PyErr_Occurred()) SWIG_fail;
40877 }
40878 Py_INCREF(Py_None); resultobj = Py_None;
40879 return resultobj;
40880 fail:
40881 return NULL;
40882 }
40883
40884
40885 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40886 PyObject *resultobj;
40887 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40888 int arg2 ;
40889 PyObject * obj0 = 0 ;
40890 PyObject * obj1 = 0 ;
40891 char *kwnames[] = {
40892 (char *) "self",(char *) "rows", NULL
40893 };
40894
40895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40897 if (SWIG_arg_fail(1)) SWIG_fail;
40898 {
40899 arg2 = (int)(SWIG_As_int(obj1));
40900 if (SWIG_arg_fail(2)) SWIG_fail;
40901 }
40902 {
40903 PyThreadState* __tstate = wxPyBeginAllowThreads();
40904 (arg1)->SetRows(arg2);
40905
40906 wxPyEndAllowThreads(__tstate);
40907 if (PyErr_Occurred()) SWIG_fail;
40908 }
40909 Py_INCREF(Py_None); resultobj = Py_None;
40910 return resultobj;
40911 fail:
40912 return NULL;
40913 }
40914
40915
40916 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40917 PyObject *resultobj;
40918 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40919 int arg2 ;
40920 PyObject * obj0 = 0 ;
40921 PyObject * obj1 = 0 ;
40922 char *kwnames[] = {
40923 (char *) "self",(char *) "gap", NULL
40924 };
40925
40926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40928 if (SWIG_arg_fail(1)) SWIG_fail;
40929 {
40930 arg2 = (int)(SWIG_As_int(obj1));
40931 if (SWIG_arg_fail(2)) SWIG_fail;
40932 }
40933 {
40934 PyThreadState* __tstate = wxPyBeginAllowThreads();
40935 (arg1)->SetVGap(arg2);
40936
40937 wxPyEndAllowThreads(__tstate);
40938 if (PyErr_Occurred()) SWIG_fail;
40939 }
40940 Py_INCREF(Py_None); resultobj = Py_None;
40941 return resultobj;
40942 fail:
40943 return NULL;
40944 }
40945
40946
40947 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40948 PyObject *resultobj;
40949 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40950 int arg2 ;
40951 PyObject * obj0 = 0 ;
40952 PyObject * obj1 = 0 ;
40953 char *kwnames[] = {
40954 (char *) "self",(char *) "gap", NULL
40955 };
40956
40957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40959 if (SWIG_arg_fail(1)) SWIG_fail;
40960 {
40961 arg2 = (int)(SWIG_As_int(obj1));
40962 if (SWIG_arg_fail(2)) SWIG_fail;
40963 }
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 (arg1)->SetHGap(arg2);
40967
40968 wxPyEndAllowThreads(__tstate);
40969 if (PyErr_Occurred()) SWIG_fail;
40970 }
40971 Py_INCREF(Py_None); resultobj = Py_None;
40972 return resultobj;
40973 fail:
40974 return NULL;
40975 }
40976
40977
40978 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40979 PyObject *resultobj;
40980 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40981 int result;
40982 PyObject * obj0 = 0 ;
40983 char *kwnames[] = {
40984 (char *) "self", NULL
40985 };
40986
40987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40989 if (SWIG_arg_fail(1)) SWIG_fail;
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 result = (int)(arg1)->GetCols();
40993
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 {
40998 resultobj = SWIG_From_int((int)(result));
40999 }
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41007 PyObject *resultobj;
41008 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41009 int result;
41010 PyObject * obj0 = 0 ;
41011 char *kwnames[] = {
41012 (char *) "self", NULL
41013 };
41014
41015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41017 if (SWIG_arg_fail(1)) SWIG_fail;
41018 {
41019 PyThreadState* __tstate = wxPyBeginAllowThreads();
41020 result = (int)(arg1)->GetRows();
41021
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 {
41026 resultobj = SWIG_From_int((int)(result));
41027 }
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj;
41036 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41037 int result;
41038 PyObject * obj0 = 0 ;
41039 char *kwnames[] = {
41040 (char *) "self", NULL
41041 };
41042
41043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41045 if (SWIG_arg_fail(1)) SWIG_fail;
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 result = (int)(arg1)->GetVGap();
41049
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 {
41054 resultobj = SWIG_From_int((int)(result));
41055 }
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj;
41064 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41065 int result;
41066 PyObject * obj0 = 0 ;
41067 char *kwnames[] = {
41068 (char *) "self", NULL
41069 };
41070
41071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41073 if (SWIG_arg_fail(1)) SWIG_fail;
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (int)(arg1)->GetHGap();
41077
41078 wxPyEndAllowThreads(__tstate);
41079 if (PyErr_Occurred()) SWIG_fail;
41080 }
41081 {
41082 resultobj = SWIG_From_int((int)(result));
41083 }
41084 return resultobj;
41085 fail:
41086 return NULL;
41087 }
41088
41089
41090 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41091 PyObject *obj;
41092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41093 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41094 Py_INCREF(obj);
41095 return Py_BuildValue((char *)"");
41096 }
41097 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj;
41099 int arg1 = (int) 1 ;
41100 int arg2 = (int) 0 ;
41101 int arg3 = (int) 0 ;
41102 int arg4 = (int) 0 ;
41103 wxFlexGridSizer *result;
41104 PyObject * obj0 = 0 ;
41105 PyObject * obj1 = 0 ;
41106 PyObject * obj2 = 0 ;
41107 PyObject * obj3 = 0 ;
41108 char *kwnames[] = {
41109 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41110 };
41111
41112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41113 if (obj0) {
41114 {
41115 arg1 = (int)(SWIG_As_int(obj0));
41116 if (SWIG_arg_fail(1)) SWIG_fail;
41117 }
41118 }
41119 if (obj1) {
41120 {
41121 arg2 = (int)(SWIG_As_int(obj1));
41122 if (SWIG_arg_fail(2)) SWIG_fail;
41123 }
41124 }
41125 if (obj2) {
41126 {
41127 arg3 = (int)(SWIG_As_int(obj2));
41128 if (SWIG_arg_fail(3)) SWIG_fail;
41129 }
41130 }
41131 if (obj3) {
41132 {
41133 arg4 = (int)(SWIG_As_int(obj3));
41134 if (SWIG_arg_fail(4)) SWIG_fail;
41135 }
41136 }
41137 {
41138 PyThreadState* __tstate = wxPyBeginAllowThreads();
41139 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41140
41141 wxPyEndAllowThreads(__tstate);
41142 if (PyErr_Occurred()) SWIG_fail;
41143 }
41144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41145 return resultobj;
41146 fail:
41147 return NULL;
41148 }
41149
41150
41151 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41152 PyObject *resultobj;
41153 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41154 size_t arg2 ;
41155 int arg3 = (int) 0 ;
41156 PyObject * obj0 = 0 ;
41157 PyObject * obj1 = 0 ;
41158 PyObject * obj2 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 {
41167 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41168 if (SWIG_arg_fail(2)) SWIG_fail;
41169 }
41170 if (obj2) {
41171 {
41172 arg3 = (int)(SWIG_As_int(obj2));
41173 if (SWIG_arg_fail(3)) SWIG_fail;
41174 }
41175 }
41176 {
41177 PyThreadState* __tstate = wxPyBeginAllowThreads();
41178 (arg1)->AddGrowableRow(arg2,arg3);
41179
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 Py_INCREF(Py_None); resultobj = Py_None;
41184 return resultobj;
41185 fail:
41186 return NULL;
41187 }
41188
41189
41190 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj;
41192 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41193 size_t arg2 ;
41194 PyObject * obj0 = 0 ;
41195 PyObject * obj1 = 0 ;
41196 char *kwnames[] = {
41197 (char *) "self",(char *) "idx", NULL
41198 };
41199
41200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41202 if (SWIG_arg_fail(1)) SWIG_fail;
41203 {
41204 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41205 if (SWIG_arg_fail(2)) SWIG_fail;
41206 }
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 (arg1)->RemoveGrowableRow(arg2);
41210
41211 wxPyEndAllowThreads(__tstate);
41212 if (PyErr_Occurred()) SWIG_fail;
41213 }
41214 Py_INCREF(Py_None); resultobj = Py_None;
41215 return resultobj;
41216 fail:
41217 return NULL;
41218 }
41219
41220
41221 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41222 PyObject *resultobj;
41223 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41224 size_t arg2 ;
41225 int arg3 = (int) 0 ;
41226 PyObject * obj0 = 0 ;
41227 PyObject * obj1 = 0 ;
41228 PyObject * obj2 = 0 ;
41229 char *kwnames[] = {
41230 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41231 };
41232
41233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41235 if (SWIG_arg_fail(1)) SWIG_fail;
41236 {
41237 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41238 if (SWIG_arg_fail(2)) SWIG_fail;
41239 }
41240 if (obj2) {
41241 {
41242 arg3 = (int)(SWIG_As_int(obj2));
41243 if (SWIG_arg_fail(3)) SWIG_fail;
41244 }
41245 }
41246 {
41247 PyThreadState* __tstate = wxPyBeginAllowThreads();
41248 (arg1)->AddGrowableCol(arg2,arg3);
41249
41250 wxPyEndAllowThreads(__tstate);
41251 if (PyErr_Occurred()) SWIG_fail;
41252 }
41253 Py_INCREF(Py_None); resultobj = Py_None;
41254 return resultobj;
41255 fail:
41256 return NULL;
41257 }
41258
41259
41260 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41261 PyObject *resultobj;
41262 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41263 size_t arg2 ;
41264 PyObject * obj0 = 0 ;
41265 PyObject * obj1 = 0 ;
41266 char *kwnames[] = {
41267 (char *) "self",(char *) "idx", NULL
41268 };
41269
41270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41272 if (SWIG_arg_fail(1)) SWIG_fail;
41273 {
41274 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41275 if (SWIG_arg_fail(2)) SWIG_fail;
41276 }
41277 {
41278 PyThreadState* __tstate = wxPyBeginAllowThreads();
41279 (arg1)->RemoveGrowableCol(arg2);
41280
41281 wxPyEndAllowThreads(__tstate);
41282 if (PyErr_Occurred()) SWIG_fail;
41283 }
41284 Py_INCREF(Py_None); resultobj = Py_None;
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj;
41293 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41294 int arg2 ;
41295 PyObject * obj0 = 0 ;
41296 PyObject * obj1 = 0 ;
41297 char *kwnames[] = {
41298 (char *) "self",(char *) "direction", NULL
41299 };
41300
41301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41303 if (SWIG_arg_fail(1)) SWIG_fail;
41304 {
41305 arg2 = (int)(SWIG_As_int(obj1));
41306 if (SWIG_arg_fail(2)) SWIG_fail;
41307 }
41308 {
41309 PyThreadState* __tstate = wxPyBeginAllowThreads();
41310 (arg1)->SetFlexibleDirection(arg2);
41311
41312 wxPyEndAllowThreads(__tstate);
41313 if (PyErr_Occurred()) SWIG_fail;
41314 }
41315 Py_INCREF(Py_None); resultobj = Py_None;
41316 return resultobj;
41317 fail:
41318 return NULL;
41319 }
41320
41321
41322 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41323 PyObject *resultobj;
41324 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41325 int result;
41326 PyObject * obj0 = 0 ;
41327 char *kwnames[] = {
41328 (char *) "self", NULL
41329 };
41330
41331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41333 if (SWIG_arg_fail(1)) SWIG_fail;
41334 {
41335 PyThreadState* __tstate = wxPyBeginAllowThreads();
41336 result = (int)(arg1)->GetFlexibleDirection();
41337
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 {
41342 resultobj = SWIG_From_int((int)(result));
41343 }
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41351 PyObject *resultobj;
41352 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41353 wxFlexSizerGrowMode arg2 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 char *kwnames[] = {
41357 (char *) "self",(char *) "mode", NULL
41358 };
41359
41360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41362 if (SWIG_arg_fail(1)) SWIG_fail;
41363 {
41364 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41365 if (SWIG_arg_fail(2)) SWIG_fail;
41366 }
41367 {
41368 PyThreadState* __tstate = wxPyBeginAllowThreads();
41369 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41370
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 Py_INCREF(Py_None); resultobj = Py_None;
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41382 PyObject *resultobj;
41383 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41384 wxFlexSizerGrowMode result;
41385 PyObject * obj0 = 0 ;
41386 char *kwnames[] = {
41387 (char *) "self", NULL
41388 };
41389
41390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41392 if (SWIG_arg_fail(1)) SWIG_fail;
41393 {
41394 PyThreadState* __tstate = wxPyBeginAllowThreads();
41395 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41396
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 resultobj = SWIG_From_int((result));
41401 return resultobj;
41402 fail:
41403 return NULL;
41404 }
41405
41406
41407 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41408 PyObject *resultobj;
41409 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41410 wxArrayInt *result;
41411 PyObject * obj0 = 0 ;
41412 char *kwnames[] = {
41413 (char *) "self", NULL
41414 };
41415
41416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41418 if (SWIG_arg_fail(1)) SWIG_fail;
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 {
41422 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41423 result = (wxArrayInt *) &_result_ref;
41424 }
41425
41426 wxPyEndAllowThreads(__tstate);
41427 if (PyErr_Occurred()) SWIG_fail;
41428 }
41429 {
41430 resultobj = PyList_New(0);
41431 size_t idx;
41432 for (idx = 0; idx < result->GetCount(); idx += 1) {
41433 PyObject* val = PyInt_FromLong( result->Item(idx) );
41434 PyList_Append(resultobj, val);
41435 Py_DECREF(val);
41436 }
41437 }
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj;
41446 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41447 wxArrayInt *result;
41448 PyObject * obj0 = 0 ;
41449 char *kwnames[] = {
41450 (char *) "self", NULL
41451 };
41452
41453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41455 if (SWIG_arg_fail(1)) SWIG_fail;
41456 {
41457 PyThreadState* __tstate = wxPyBeginAllowThreads();
41458 {
41459 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41460 result = (wxArrayInt *) &_result_ref;
41461 }
41462
41463 wxPyEndAllowThreads(__tstate);
41464 if (PyErr_Occurred()) SWIG_fail;
41465 }
41466 {
41467 resultobj = PyList_New(0);
41468 size_t idx;
41469 for (idx = 0; idx < result->GetCount(); idx += 1) {
41470 PyObject* val = PyInt_FromLong( result->Item(idx) );
41471 PyList_Append(resultobj, val);
41472 Py_DECREF(val);
41473 }
41474 }
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41482 PyObject *obj;
41483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41484 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41485 Py_INCREF(obj);
41486 return Py_BuildValue((char *)"");
41487 }
41488 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj;
41490 wxStdDialogButtonSizer *result;
41491 char *kwnames[] = {
41492 NULL
41493 };
41494
41495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41499
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41504 return resultobj;
41505 fail:
41506 return NULL;
41507 }
41508
41509
41510 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41511 PyObject *resultobj;
41512 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41513 wxButton *arg2 = (wxButton *) 0 ;
41514 PyObject * obj0 = 0 ;
41515 PyObject * obj1 = 0 ;
41516 char *kwnames[] = {
41517 (char *) "self",(char *) "button", NULL
41518 };
41519
41520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41522 if (SWIG_arg_fail(1)) SWIG_fail;
41523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41524 if (SWIG_arg_fail(2)) SWIG_fail;
41525 {
41526 PyThreadState* __tstate = wxPyBeginAllowThreads();
41527 (arg1)->AddButton(arg2);
41528
41529 wxPyEndAllowThreads(__tstate);
41530 if (PyErr_Occurred()) SWIG_fail;
41531 }
41532 Py_INCREF(Py_None); resultobj = Py_None;
41533 return resultobj;
41534 fail:
41535 return NULL;
41536 }
41537
41538
41539 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41540 PyObject *resultobj;
41541 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41542 PyObject * obj0 = 0 ;
41543 char *kwnames[] = {
41544 (char *) "self", NULL
41545 };
41546
41547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41549 if (SWIG_arg_fail(1)) SWIG_fail;
41550 {
41551 PyThreadState* __tstate = wxPyBeginAllowThreads();
41552 (arg1)->Realize();
41553
41554 wxPyEndAllowThreads(__tstate);
41555 if (PyErr_Occurred()) SWIG_fail;
41556 }
41557 Py_INCREF(Py_None); resultobj = Py_None;
41558 return resultobj;
41559 fail:
41560 return NULL;
41561 }
41562
41563
41564 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41565 PyObject *resultobj;
41566 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41567 wxButton *arg2 = (wxButton *) 0 ;
41568 PyObject * obj0 = 0 ;
41569 PyObject * obj1 = 0 ;
41570 char *kwnames[] = {
41571 (char *) "self",(char *) "button", NULL
41572 };
41573
41574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41576 if (SWIG_arg_fail(1)) SWIG_fail;
41577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41578 if (SWIG_arg_fail(2)) SWIG_fail;
41579 {
41580 PyThreadState* __tstate = wxPyBeginAllowThreads();
41581 (arg1)->SetAffirmativeButton(arg2);
41582
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 Py_INCREF(Py_None); resultobj = Py_None;
41587 return resultobj;
41588 fail:
41589 return NULL;
41590 }
41591
41592
41593 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41594 PyObject *resultobj;
41595 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41596 wxButton *arg2 = (wxButton *) 0 ;
41597 PyObject * obj0 = 0 ;
41598 PyObject * obj1 = 0 ;
41599 char *kwnames[] = {
41600 (char *) "self",(char *) "button", NULL
41601 };
41602
41603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41605 if (SWIG_arg_fail(1)) SWIG_fail;
41606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41607 if (SWIG_arg_fail(2)) SWIG_fail;
41608 {
41609 PyThreadState* __tstate = wxPyBeginAllowThreads();
41610 (arg1)->SetNegativeButton(arg2);
41611
41612 wxPyEndAllowThreads(__tstate);
41613 if (PyErr_Occurred()) SWIG_fail;
41614 }
41615 Py_INCREF(Py_None); resultobj = Py_None;
41616 return resultobj;
41617 fail:
41618 return NULL;
41619 }
41620
41621
41622 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41623 PyObject *resultobj;
41624 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41625 wxButton *arg2 = (wxButton *) 0 ;
41626 PyObject * obj0 = 0 ;
41627 PyObject * obj1 = 0 ;
41628 char *kwnames[] = {
41629 (char *) "self",(char *) "button", NULL
41630 };
41631
41632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41634 if (SWIG_arg_fail(1)) SWIG_fail;
41635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41636 if (SWIG_arg_fail(2)) SWIG_fail;
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 (arg1)->SetCancelButton(arg2);
41640
41641 wxPyEndAllowThreads(__tstate);
41642 if (PyErr_Occurred()) SWIG_fail;
41643 }
41644 Py_INCREF(Py_None); resultobj = Py_None;
41645 return resultobj;
41646 fail:
41647 return NULL;
41648 }
41649
41650
41651 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41652 PyObject *resultobj;
41653 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41654 wxButton *result;
41655 PyObject * obj0 = 0 ;
41656 char *kwnames[] = {
41657 (char *) "self", NULL
41658 };
41659
41660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41662 if (SWIG_arg_fail(1)) SWIG_fail;
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41666
41667 wxPyEndAllowThreads(__tstate);
41668 if (PyErr_Occurred()) SWIG_fail;
41669 }
41670 {
41671 resultobj = wxPyMake_wxObject(result, 0);
41672 }
41673 return resultobj;
41674 fail:
41675 return NULL;
41676 }
41677
41678
41679 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41680 PyObject *resultobj;
41681 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41682 wxButton *result;
41683 PyObject * obj0 = 0 ;
41684 char *kwnames[] = {
41685 (char *) "self", NULL
41686 };
41687
41688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41690 if (SWIG_arg_fail(1)) SWIG_fail;
41691 {
41692 PyThreadState* __tstate = wxPyBeginAllowThreads();
41693 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41694
41695 wxPyEndAllowThreads(__tstate);
41696 if (PyErr_Occurred()) SWIG_fail;
41697 }
41698 {
41699 resultobj = wxPyMake_wxObject(result, 0);
41700 }
41701 return resultobj;
41702 fail:
41703 return NULL;
41704 }
41705
41706
41707 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41708 PyObject *resultobj;
41709 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41710 wxButton *result;
41711 PyObject * obj0 = 0 ;
41712 char *kwnames[] = {
41713 (char *) "self", NULL
41714 };
41715
41716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41718 if (SWIG_arg_fail(1)) SWIG_fail;
41719 {
41720 PyThreadState* __tstate = wxPyBeginAllowThreads();
41721 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41722
41723 wxPyEndAllowThreads(__tstate);
41724 if (PyErr_Occurred()) SWIG_fail;
41725 }
41726 {
41727 resultobj = wxPyMake_wxObject(result, 0);
41728 }
41729 return resultobj;
41730 fail:
41731 return NULL;
41732 }
41733
41734
41735 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41736 PyObject *resultobj;
41737 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41738 wxButton *result;
41739 PyObject * obj0 = 0 ;
41740 char *kwnames[] = {
41741 (char *) "self", NULL
41742 };
41743
41744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41746 if (SWIG_arg_fail(1)) SWIG_fail;
41747 {
41748 PyThreadState* __tstate = wxPyBeginAllowThreads();
41749 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41750
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 {
41755 resultobj = wxPyMake_wxObject(result, 0);
41756 }
41757 return resultobj;
41758 fail:
41759 return NULL;
41760 }
41761
41762
41763 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41764 PyObject *resultobj;
41765 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41766 wxButton *result;
41767 PyObject * obj0 = 0 ;
41768 char *kwnames[] = {
41769 (char *) "self", NULL
41770 };
41771
41772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41774 if (SWIG_arg_fail(1)) SWIG_fail;
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41778
41779 wxPyEndAllowThreads(__tstate);
41780 if (PyErr_Occurred()) SWIG_fail;
41781 }
41782 {
41783 resultobj = wxPyMake_wxObject(result, 0);
41784 }
41785 return resultobj;
41786 fail:
41787 return NULL;
41788 }
41789
41790
41791 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41792 PyObject *obj;
41793 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41794 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41795 Py_INCREF(obj);
41796 return Py_BuildValue((char *)"");
41797 }
41798 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41799 PyObject *resultobj;
41800 int arg1 = (int) 0 ;
41801 int arg2 = (int) 0 ;
41802 wxGBPosition *result;
41803 PyObject * obj0 = 0 ;
41804 PyObject * obj1 = 0 ;
41805 char *kwnames[] = {
41806 (char *) "row",(char *) "col", NULL
41807 };
41808
41809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41810 if (obj0) {
41811 {
41812 arg1 = (int)(SWIG_As_int(obj0));
41813 if (SWIG_arg_fail(1)) SWIG_fail;
41814 }
41815 }
41816 if (obj1) {
41817 {
41818 arg2 = (int)(SWIG_As_int(obj1));
41819 if (SWIG_arg_fail(2)) SWIG_fail;
41820 }
41821 }
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41825
41826 wxPyEndAllowThreads(__tstate);
41827 if (PyErr_Occurred()) SWIG_fail;
41828 }
41829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41830 return resultobj;
41831 fail:
41832 return NULL;
41833 }
41834
41835
41836 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41837 PyObject *resultobj;
41838 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41839 int result;
41840 PyObject * obj0 = 0 ;
41841 char *kwnames[] = {
41842 (char *) "self", NULL
41843 };
41844
41845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41847 if (SWIG_arg_fail(1)) SWIG_fail;
41848 {
41849 PyThreadState* __tstate = wxPyBeginAllowThreads();
41850 result = (int)((wxGBPosition const *)arg1)->GetRow();
41851
41852 wxPyEndAllowThreads(__tstate);
41853 if (PyErr_Occurred()) SWIG_fail;
41854 }
41855 {
41856 resultobj = SWIG_From_int((int)(result));
41857 }
41858 return resultobj;
41859 fail:
41860 return NULL;
41861 }
41862
41863
41864 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41865 PyObject *resultobj;
41866 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41867 int result;
41868 PyObject * obj0 = 0 ;
41869 char *kwnames[] = {
41870 (char *) "self", NULL
41871 };
41872
41873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41875 if (SWIG_arg_fail(1)) SWIG_fail;
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 result = (int)((wxGBPosition const *)arg1)->GetCol();
41879
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = SWIG_From_int((int)(result));
41885 }
41886 return resultobj;
41887 fail:
41888 return NULL;
41889 }
41890
41891
41892 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41893 PyObject *resultobj;
41894 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41895 int arg2 ;
41896 PyObject * obj0 = 0 ;
41897 PyObject * obj1 = 0 ;
41898 char *kwnames[] = {
41899 (char *) "self",(char *) "row", NULL
41900 };
41901
41902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41904 if (SWIG_arg_fail(1)) SWIG_fail;
41905 {
41906 arg2 = (int)(SWIG_As_int(obj1));
41907 if (SWIG_arg_fail(2)) SWIG_fail;
41908 }
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 (arg1)->SetRow(arg2);
41912
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 Py_INCREF(Py_None); resultobj = Py_None;
41917 return resultobj;
41918 fail:
41919 return NULL;
41920 }
41921
41922
41923 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj;
41925 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41926 int arg2 ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 char *kwnames[] = {
41930 (char *) "self",(char *) "col", NULL
41931 };
41932
41933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41935 if (SWIG_arg_fail(1)) SWIG_fail;
41936 {
41937 arg2 = (int)(SWIG_As_int(obj1));
41938 if (SWIG_arg_fail(2)) SWIG_fail;
41939 }
41940 {
41941 PyThreadState* __tstate = wxPyBeginAllowThreads();
41942 (arg1)->SetCol(arg2);
41943
41944 wxPyEndAllowThreads(__tstate);
41945 if (PyErr_Occurred()) SWIG_fail;
41946 }
41947 Py_INCREF(Py_None); resultobj = Py_None;
41948 return resultobj;
41949 fail:
41950 return NULL;
41951 }
41952
41953
41954 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41955 PyObject *resultobj;
41956 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41957 wxGBPosition *arg2 = 0 ;
41958 bool result;
41959 wxGBPosition temp2 ;
41960 PyObject * obj0 = 0 ;
41961 PyObject * obj1 = 0 ;
41962 char *kwnames[] = {
41963 (char *) "self",(char *) "other", NULL
41964 };
41965
41966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41968 if (SWIG_arg_fail(1)) SWIG_fail;
41969 {
41970 arg2 = &temp2;
41971 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41972 }
41973 {
41974 PyThreadState* __tstate = wxPyBeginAllowThreads();
41975 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41976
41977 wxPyEndAllowThreads(__tstate);
41978 if (PyErr_Occurred()) SWIG_fail;
41979 }
41980 {
41981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41982 }
41983 return resultobj;
41984 fail:
41985 return NULL;
41986 }
41987
41988
41989 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41990 PyObject *resultobj;
41991 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41992 wxGBPosition *arg2 = 0 ;
41993 bool result;
41994 wxGBPosition temp2 ;
41995 PyObject * obj0 = 0 ;
41996 PyObject * obj1 = 0 ;
41997 char *kwnames[] = {
41998 (char *) "self",(char *) "other", NULL
41999 };
42000
42001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42003 if (SWIG_arg_fail(1)) SWIG_fail;
42004 {
42005 arg2 = &temp2;
42006 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42007 }
42008 {
42009 PyThreadState* __tstate = wxPyBeginAllowThreads();
42010 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42011
42012 wxPyEndAllowThreads(__tstate);
42013 if (PyErr_Occurred()) SWIG_fail;
42014 }
42015 {
42016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42017 }
42018 return resultobj;
42019 fail:
42020 return NULL;
42021 }
42022
42023
42024 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42025 PyObject *resultobj;
42026 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42027 int arg2 = (int) 0 ;
42028 int arg3 = (int) 0 ;
42029 PyObject * obj0 = 0 ;
42030 PyObject * obj1 = 0 ;
42031 PyObject * obj2 = 0 ;
42032 char *kwnames[] = {
42033 (char *) "self",(char *) "row",(char *) "col", NULL
42034 };
42035
42036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42038 if (SWIG_arg_fail(1)) SWIG_fail;
42039 if (obj1) {
42040 {
42041 arg2 = (int)(SWIG_As_int(obj1));
42042 if (SWIG_arg_fail(2)) SWIG_fail;
42043 }
42044 }
42045 if (obj2) {
42046 {
42047 arg3 = (int)(SWIG_As_int(obj2));
42048 if (SWIG_arg_fail(3)) SWIG_fail;
42049 }
42050 }
42051 {
42052 PyThreadState* __tstate = wxPyBeginAllowThreads();
42053 wxGBPosition_Set(arg1,arg2,arg3);
42054
42055 wxPyEndAllowThreads(__tstate);
42056 if (PyErr_Occurred()) SWIG_fail;
42057 }
42058 Py_INCREF(Py_None); resultobj = Py_None;
42059 return resultobj;
42060 fail:
42061 return NULL;
42062 }
42063
42064
42065 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42066 PyObject *resultobj;
42067 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42068 PyObject *result;
42069 PyObject * obj0 = 0 ;
42070 char *kwnames[] = {
42071 (char *) "self", NULL
42072 };
42073
42074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42076 if (SWIG_arg_fail(1)) SWIG_fail;
42077 {
42078 PyThreadState* __tstate = wxPyBeginAllowThreads();
42079 result = (PyObject *)wxGBPosition_Get(arg1);
42080
42081 wxPyEndAllowThreads(__tstate);
42082 if (PyErr_Occurred()) SWIG_fail;
42083 }
42084 resultobj = result;
42085 return resultobj;
42086 fail:
42087 return NULL;
42088 }
42089
42090
42091 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42092 PyObject *obj;
42093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42094 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42095 Py_INCREF(obj);
42096 return Py_BuildValue((char *)"");
42097 }
42098 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj;
42100 int arg1 = (int) 1 ;
42101 int arg2 = (int) 1 ;
42102 wxGBSpan *result;
42103 PyObject * obj0 = 0 ;
42104 PyObject * obj1 = 0 ;
42105 char *kwnames[] = {
42106 (char *) "rowspan",(char *) "colspan", NULL
42107 };
42108
42109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42110 if (obj0) {
42111 {
42112 arg1 = (int)(SWIG_As_int(obj0));
42113 if (SWIG_arg_fail(1)) SWIG_fail;
42114 }
42115 }
42116 if (obj1) {
42117 {
42118 arg2 = (int)(SWIG_As_int(obj1));
42119 if (SWIG_arg_fail(2)) SWIG_fail;
42120 }
42121 }
42122 {
42123 PyThreadState* __tstate = wxPyBeginAllowThreads();
42124 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42125
42126 wxPyEndAllowThreads(__tstate);
42127 if (PyErr_Occurred()) SWIG_fail;
42128 }
42129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42130 return resultobj;
42131 fail:
42132 return NULL;
42133 }
42134
42135
42136 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42137 PyObject *resultobj;
42138 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42139 int result;
42140 PyObject * obj0 = 0 ;
42141 char *kwnames[] = {
42142 (char *) "self", NULL
42143 };
42144
42145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42147 if (SWIG_arg_fail(1)) SWIG_fail;
42148 {
42149 PyThreadState* __tstate = wxPyBeginAllowThreads();
42150 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42151
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 {
42156 resultobj = SWIG_From_int((int)(result));
42157 }
42158 return resultobj;
42159 fail:
42160 return NULL;
42161 }
42162
42163
42164 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42165 PyObject *resultobj;
42166 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42167 int result;
42168 PyObject * obj0 = 0 ;
42169 char *kwnames[] = {
42170 (char *) "self", NULL
42171 };
42172
42173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42175 if (SWIG_arg_fail(1)) SWIG_fail;
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42179
42180 wxPyEndAllowThreads(__tstate);
42181 if (PyErr_Occurred()) SWIG_fail;
42182 }
42183 {
42184 resultobj = SWIG_From_int((int)(result));
42185 }
42186 return resultobj;
42187 fail:
42188 return NULL;
42189 }
42190
42191
42192 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42193 PyObject *resultobj;
42194 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42195 int arg2 ;
42196 PyObject * obj0 = 0 ;
42197 PyObject * obj1 = 0 ;
42198 char *kwnames[] = {
42199 (char *) "self",(char *) "rowspan", NULL
42200 };
42201
42202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42204 if (SWIG_arg_fail(1)) SWIG_fail;
42205 {
42206 arg2 = (int)(SWIG_As_int(obj1));
42207 if (SWIG_arg_fail(2)) SWIG_fail;
42208 }
42209 {
42210 PyThreadState* __tstate = wxPyBeginAllowThreads();
42211 (arg1)->SetRowspan(arg2);
42212
42213 wxPyEndAllowThreads(__tstate);
42214 if (PyErr_Occurred()) SWIG_fail;
42215 }
42216 Py_INCREF(Py_None); resultobj = Py_None;
42217 return resultobj;
42218 fail:
42219 return NULL;
42220 }
42221
42222
42223 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42224 PyObject *resultobj;
42225 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42226 int arg2 ;
42227 PyObject * obj0 = 0 ;
42228 PyObject * obj1 = 0 ;
42229 char *kwnames[] = {
42230 (char *) "self",(char *) "colspan", NULL
42231 };
42232
42233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42235 if (SWIG_arg_fail(1)) SWIG_fail;
42236 {
42237 arg2 = (int)(SWIG_As_int(obj1));
42238 if (SWIG_arg_fail(2)) SWIG_fail;
42239 }
42240 {
42241 PyThreadState* __tstate = wxPyBeginAllowThreads();
42242 (arg1)->SetColspan(arg2);
42243
42244 wxPyEndAllowThreads(__tstate);
42245 if (PyErr_Occurred()) SWIG_fail;
42246 }
42247 Py_INCREF(Py_None); resultobj = Py_None;
42248 return resultobj;
42249 fail:
42250 return NULL;
42251 }
42252
42253
42254 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42255 PyObject *resultobj;
42256 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42257 wxGBSpan *arg2 = 0 ;
42258 bool result;
42259 wxGBSpan temp2 ;
42260 PyObject * obj0 = 0 ;
42261 PyObject * obj1 = 0 ;
42262 char *kwnames[] = {
42263 (char *) "self",(char *) "other", NULL
42264 };
42265
42266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42268 if (SWIG_arg_fail(1)) SWIG_fail;
42269 {
42270 arg2 = &temp2;
42271 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42272 }
42273 {
42274 PyThreadState* __tstate = wxPyBeginAllowThreads();
42275 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42276
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 {
42281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42282 }
42283 return resultobj;
42284 fail:
42285 return NULL;
42286 }
42287
42288
42289 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42290 PyObject *resultobj;
42291 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42292 wxGBSpan *arg2 = 0 ;
42293 bool result;
42294 wxGBSpan temp2 ;
42295 PyObject * obj0 = 0 ;
42296 PyObject * obj1 = 0 ;
42297 char *kwnames[] = {
42298 (char *) "self",(char *) "other", NULL
42299 };
42300
42301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42303 if (SWIG_arg_fail(1)) SWIG_fail;
42304 {
42305 arg2 = &temp2;
42306 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42307 }
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42311
42312 wxPyEndAllowThreads(__tstate);
42313 if (PyErr_Occurred()) SWIG_fail;
42314 }
42315 {
42316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42317 }
42318 return resultobj;
42319 fail:
42320 return NULL;
42321 }
42322
42323
42324 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42325 PyObject *resultobj;
42326 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42327 int arg2 = (int) 1 ;
42328 int arg3 = (int) 1 ;
42329 PyObject * obj0 = 0 ;
42330 PyObject * obj1 = 0 ;
42331 PyObject * obj2 = 0 ;
42332 char *kwnames[] = {
42333 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42334 };
42335
42336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42338 if (SWIG_arg_fail(1)) SWIG_fail;
42339 if (obj1) {
42340 {
42341 arg2 = (int)(SWIG_As_int(obj1));
42342 if (SWIG_arg_fail(2)) SWIG_fail;
42343 }
42344 }
42345 if (obj2) {
42346 {
42347 arg3 = (int)(SWIG_As_int(obj2));
42348 if (SWIG_arg_fail(3)) SWIG_fail;
42349 }
42350 }
42351 {
42352 PyThreadState* __tstate = wxPyBeginAllowThreads();
42353 wxGBSpan_Set(arg1,arg2,arg3);
42354
42355 wxPyEndAllowThreads(__tstate);
42356 if (PyErr_Occurred()) SWIG_fail;
42357 }
42358 Py_INCREF(Py_None); resultobj = Py_None;
42359 return resultobj;
42360 fail:
42361 return NULL;
42362 }
42363
42364
42365 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42366 PyObject *resultobj;
42367 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42368 PyObject *result;
42369 PyObject * obj0 = 0 ;
42370 char *kwnames[] = {
42371 (char *) "self", NULL
42372 };
42373
42374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42376 if (SWIG_arg_fail(1)) SWIG_fail;
42377 {
42378 PyThreadState* __tstate = wxPyBeginAllowThreads();
42379 result = (PyObject *)wxGBSpan_Get(arg1);
42380
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 resultobj = result;
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42392 PyObject *obj;
42393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42394 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42395 Py_INCREF(obj);
42396 return Py_BuildValue((char *)"");
42397 }
42398 static int _wrap_DefaultSpan_set(PyObject *) {
42399 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42400 return 1;
42401 }
42402
42403
42404 static PyObject *_wrap_DefaultSpan_get(void) {
42405 PyObject *pyobj;
42406
42407 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42408 return pyobj;
42409 }
42410
42411
42412 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42413 PyObject *resultobj;
42414 wxGBSizerItem *result;
42415 char *kwnames[] = {
42416 NULL
42417 };
42418
42419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42420 {
42421 PyThreadState* __tstate = wxPyBeginAllowThreads();
42422 result = (wxGBSizerItem *)new wxGBSizerItem();
42423
42424 wxPyEndAllowThreads(__tstate);
42425 if (PyErr_Occurred()) SWIG_fail;
42426 }
42427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42428 return resultobj;
42429 fail:
42430 return NULL;
42431 }
42432
42433
42434 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42435 PyObject *resultobj;
42436 wxWindow *arg1 = (wxWindow *) 0 ;
42437 wxGBPosition *arg2 = 0 ;
42438 wxGBSpan *arg3 = 0 ;
42439 int arg4 ;
42440 int arg5 ;
42441 PyObject *arg6 = (PyObject *) NULL ;
42442 wxGBSizerItem *result;
42443 wxGBPosition temp2 ;
42444 wxGBSpan temp3 ;
42445 PyObject * obj0 = 0 ;
42446 PyObject * obj1 = 0 ;
42447 PyObject * obj2 = 0 ;
42448 PyObject * obj3 = 0 ;
42449 PyObject * obj4 = 0 ;
42450 PyObject * obj5 = 0 ;
42451 char *kwnames[] = {
42452 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42453 };
42454
42455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42457 if (SWIG_arg_fail(1)) SWIG_fail;
42458 {
42459 arg2 = &temp2;
42460 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42461 }
42462 {
42463 arg3 = &temp3;
42464 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42465 }
42466 {
42467 arg4 = (int)(SWIG_As_int(obj3));
42468 if (SWIG_arg_fail(4)) SWIG_fail;
42469 }
42470 {
42471 arg5 = (int)(SWIG_As_int(obj4));
42472 if (SWIG_arg_fail(5)) SWIG_fail;
42473 }
42474 if (obj5) {
42475 arg6 = obj5;
42476 }
42477 {
42478 PyThreadState* __tstate = wxPyBeginAllowThreads();
42479 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42480
42481 wxPyEndAllowThreads(__tstate);
42482 if (PyErr_Occurred()) SWIG_fail;
42483 }
42484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj;
42493 wxSizer *arg1 = (wxSizer *) 0 ;
42494 wxGBPosition *arg2 = 0 ;
42495 wxGBSpan *arg3 = 0 ;
42496 int arg4 ;
42497 int arg5 ;
42498 PyObject *arg6 = (PyObject *) NULL ;
42499 wxGBSizerItem *result;
42500 wxGBPosition temp2 ;
42501 wxGBSpan temp3 ;
42502 PyObject * obj0 = 0 ;
42503 PyObject * obj1 = 0 ;
42504 PyObject * obj2 = 0 ;
42505 PyObject * obj3 = 0 ;
42506 PyObject * obj4 = 0 ;
42507 PyObject * obj5 = 0 ;
42508 char *kwnames[] = {
42509 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42510 };
42511
42512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42514 if (SWIG_arg_fail(1)) SWIG_fail;
42515 {
42516 arg2 = &temp2;
42517 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42518 }
42519 {
42520 arg3 = &temp3;
42521 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42522 }
42523 {
42524 arg4 = (int)(SWIG_As_int(obj3));
42525 if (SWIG_arg_fail(4)) SWIG_fail;
42526 }
42527 {
42528 arg5 = (int)(SWIG_As_int(obj4));
42529 if (SWIG_arg_fail(5)) SWIG_fail;
42530 }
42531 if (obj5) {
42532 arg6 = obj5;
42533 }
42534 {
42535 PyThreadState* __tstate = wxPyBeginAllowThreads();
42536 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42537
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42542 return resultobj;
42543 fail:
42544 return NULL;
42545 }
42546
42547
42548 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42549 PyObject *resultobj;
42550 int arg1 ;
42551 int arg2 ;
42552 wxGBPosition *arg3 = 0 ;
42553 wxGBSpan *arg4 = 0 ;
42554 int arg5 ;
42555 int arg6 ;
42556 PyObject *arg7 = (PyObject *) NULL ;
42557 wxGBSizerItem *result;
42558 wxGBPosition temp3 ;
42559 wxGBSpan temp4 ;
42560 PyObject * obj0 = 0 ;
42561 PyObject * obj1 = 0 ;
42562 PyObject * obj2 = 0 ;
42563 PyObject * obj3 = 0 ;
42564 PyObject * obj4 = 0 ;
42565 PyObject * obj5 = 0 ;
42566 PyObject * obj6 = 0 ;
42567 char *kwnames[] = {
42568 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42569 };
42570
42571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42572 {
42573 arg1 = (int)(SWIG_As_int(obj0));
42574 if (SWIG_arg_fail(1)) SWIG_fail;
42575 }
42576 {
42577 arg2 = (int)(SWIG_As_int(obj1));
42578 if (SWIG_arg_fail(2)) SWIG_fail;
42579 }
42580 {
42581 arg3 = &temp3;
42582 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42583 }
42584 {
42585 arg4 = &temp4;
42586 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42587 }
42588 {
42589 arg5 = (int)(SWIG_As_int(obj4));
42590 if (SWIG_arg_fail(5)) SWIG_fail;
42591 }
42592 {
42593 arg6 = (int)(SWIG_As_int(obj5));
42594 if (SWIG_arg_fail(6)) SWIG_fail;
42595 }
42596 if (obj6) {
42597 arg7 = obj6;
42598 }
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42602
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42607 return resultobj;
42608 fail:
42609 return NULL;
42610 }
42611
42612
42613 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42614 PyObject *resultobj;
42615 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42616 wxGBPosition result;
42617 PyObject * obj0 = 0 ;
42618 char *kwnames[] = {
42619 (char *) "self", NULL
42620 };
42621
42622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42624 if (SWIG_arg_fail(1)) SWIG_fail;
42625 {
42626 PyThreadState* __tstate = wxPyBeginAllowThreads();
42627 result = ((wxGBSizerItem const *)arg1)->GetPos();
42628
42629 wxPyEndAllowThreads(__tstate);
42630 if (PyErr_Occurred()) SWIG_fail;
42631 }
42632 {
42633 wxGBPosition * resultptr;
42634 resultptr = new wxGBPosition((wxGBPosition &)(result));
42635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42636 }
42637 return resultobj;
42638 fail:
42639 return NULL;
42640 }
42641
42642
42643 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42644 PyObject *resultobj;
42645 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42646 wxGBSpan result;
42647 PyObject * obj0 = 0 ;
42648 char *kwnames[] = {
42649 (char *) "self", NULL
42650 };
42651
42652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42654 if (SWIG_arg_fail(1)) SWIG_fail;
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42658
42659 wxPyEndAllowThreads(__tstate);
42660 if (PyErr_Occurred()) SWIG_fail;
42661 }
42662 {
42663 wxGBSpan * resultptr;
42664 resultptr = new wxGBSpan((wxGBSpan &)(result));
42665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42666 }
42667 return resultobj;
42668 fail:
42669 return NULL;
42670 }
42671
42672
42673 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42674 PyObject *resultobj;
42675 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42676 wxGBPosition *arg2 = 0 ;
42677 bool result;
42678 wxGBPosition temp2 ;
42679 PyObject * obj0 = 0 ;
42680 PyObject * obj1 = 0 ;
42681 char *kwnames[] = {
42682 (char *) "self",(char *) "pos", NULL
42683 };
42684
42685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42687 if (SWIG_arg_fail(1)) SWIG_fail;
42688 {
42689 arg2 = &temp2;
42690 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42691 }
42692 {
42693 PyThreadState* __tstate = wxPyBeginAllowThreads();
42694 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42695
42696 wxPyEndAllowThreads(__tstate);
42697 if (PyErr_Occurred()) SWIG_fail;
42698 }
42699 {
42700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42701 }
42702 return resultobj;
42703 fail:
42704 return NULL;
42705 }
42706
42707
42708 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42709 PyObject *resultobj;
42710 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42711 wxGBSpan *arg2 = 0 ;
42712 bool result;
42713 wxGBSpan temp2 ;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 char *kwnames[] = {
42717 (char *) "self",(char *) "span", NULL
42718 };
42719
42720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42722 if (SWIG_arg_fail(1)) SWIG_fail;
42723 {
42724 arg2 = &temp2;
42725 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42726 }
42727 {
42728 PyThreadState* __tstate = wxPyBeginAllowThreads();
42729 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42730
42731 wxPyEndAllowThreads(__tstate);
42732 if (PyErr_Occurred()) SWIG_fail;
42733 }
42734 {
42735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42736 }
42737 return resultobj;
42738 fail:
42739 return NULL;
42740 }
42741
42742
42743 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42744 PyObject *resultobj;
42745 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42746 wxGBSizerItem *arg2 = 0 ;
42747 bool result;
42748 PyObject * obj0 = 0 ;
42749 PyObject * obj1 = 0 ;
42750 char *kwnames[] = {
42751 (char *) "self",(char *) "other", NULL
42752 };
42753
42754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42756 if (SWIG_arg_fail(1)) SWIG_fail;
42757 {
42758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42759 if (SWIG_arg_fail(2)) SWIG_fail;
42760 if (arg2 == NULL) {
42761 SWIG_null_ref("wxGBSizerItem");
42762 }
42763 if (SWIG_arg_fail(2)) SWIG_fail;
42764 }
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42768
42769 wxPyEndAllowThreads(__tstate);
42770 if (PyErr_Occurred()) SWIG_fail;
42771 }
42772 {
42773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42774 }
42775 return resultobj;
42776 fail:
42777 return NULL;
42778 }
42779
42780
42781 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42782 PyObject *resultobj;
42783 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42784 wxGBPosition *arg2 = 0 ;
42785 wxGBSpan *arg3 = 0 ;
42786 bool result;
42787 wxGBPosition temp2 ;
42788 wxGBSpan temp3 ;
42789 PyObject * obj0 = 0 ;
42790 PyObject * obj1 = 0 ;
42791 PyObject * obj2 = 0 ;
42792 char *kwnames[] = {
42793 (char *) "self",(char *) "pos",(char *) "span", NULL
42794 };
42795
42796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42798 if (SWIG_arg_fail(1)) SWIG_fail;
42799 {
42800 arg2 = &temp2;
42801 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42802 }
42803 {
42804 arg3 = &temp3;
42805 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42806 }
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42810
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 {
42815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42816 }
42817 return resultobj;
42818 fail:
42819 return NULL;
42820 }
42821
42822
42823 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42824 PyObject *resultobj;
42825 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42826 wxGBPosition result;
42827 PyObject * obj0 = 0 ;
42828 char *kwnames[] = {
42829 (char *) "self", NULL
42830 };
42831
42832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42834 if (SWIG_arg_fail(1)) SWIG_fail;
42835 {
42836 PyThreadState* __tstate = wxPyBeginAllowThreads();
42837 result = wxGBSizerItem_GetEndPos(arg1);
42838
42839 wxPyEndAllowThreads(__tstate);
42840 if (PyErr_Occurred()) SWIG_fail;
42841 }
42842 {
42843 wxGBPosition * resultptr;
42844 resultptr = new wxGBPosition((wxGBPosition &)(result));
42845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42854 PyObject *resultobj;
42855 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42856 wxGridBagSizer *result;
42857 PyObject * obj0 = 0 ;
42858 char *kwnames[] = {
42859 (char *) "self", NULL
42860 };
42861
42862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42864 if (SWIG_arg_fail(1)) SWIG_fail;
42865 {
42866 PyThreadState* __tstate = wxPyBeginAllowThreads();
42867 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42868
42869 wxPyEndAllowThreads(__tstate);
42870 if (PyErr_Occurred()) SWIG_fail;
42871 }
42872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42873 return resultobj;
42874 fail:
42875 return NULL;
42876 }
42877
42878
42879 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42880 PyObject *resultobj;
42881 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42882 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42883 PyObject * obj0 = 0 ;
42884 PyObject * obj1 = 0 ;
42885 char *kwnames[] = {
42886 (char *) "self",(char *) "sizer", NULL
42887 };
42888
42889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42891 if (SWIG_arg_fail(1)) SWIG_fail;
42892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42893 if (SWIG_arg_fail(2)) SWIG_fail;
42894 {
42895 PyThreadState* __tstate = wxPyBeginAllowThreads();
42896 (arg1)->SetGBSizer(arg2);
42897
42898 wxPyEndAllowThreads(__tstate);
42899 if (PyErr_Occurred()) SWIG_fail;
42900 }
42901 Py_INCREF(Py_None); resultobj = Py_None;
42902 return resultobj;
42903 fail:
42904 return NULL;
42905 }
42906
42907
42908 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42909 PyObject *obj;
42910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42911 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42912 Py_INCREF(obj);
42913 return Py_BuildValue((char *)"");
42914 }
42915 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42916 PyObject *resultobj;
42917 int arg1 = (int) 0 ;
42918 int arg2 = (int) 0 ;
42919 wxGridBagSizer *result;
42920 PyObject * obj0 = 0 ;
42921 PyObject * obj1 = 0 ;
42922 char *kwnames[] = {
42923 (char *) "vgap",(char *) "hgap", NULL
42924 };
42925
42926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42927 if (obj0) {
42928 {
42929 arg1 = (int)(SWIG_As_int(obj0));
42930 if (SWIG_arg_fail(1)) SWIG_fail;
42931 }
42932 }
42933 if (obj1) {
42934 {
42935 arg2 = (int)(SWIG_As_int(obj1));
42936 if (SWIG_arg_fail(2)) SWIG_fail;
42937 }
42938 }
42939 {
42940 PyThreadState* __tstate = wxPyBeginAllowThreads();
42941 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42942
42943 wxPyEndAllowThreads(__tstate);
42944 if (PyErr_Occurred()) SWIG_fail;
42945 }
42946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42947 return resultobj;
42948 fail:
42949 return NULL;
42950 }
42951
42952
42953 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42954 PyObject *resultobj;
42955 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42956 PyObject *arg2 = (PyObject *) 0 ;
42957 wxGBPosition *arg3 = 0 ;
42958 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42959 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42960 int arg5 = (int) 0 ;
42961 int arg6 = (int) 0 ;
42962 PyObject *arg7 = (PyObject *) NULL ;
42963 wxGBSizerItem *result;
42964 wxGBPosition temp3 ;
42965 wxGBSpan temp4 ;
42966 PyObject * obj0 = 0 ;
42967 PyObject * obj1 = 0 ;
42968 PyObject * obj2 = 0 ;
42969 PyObject * obj3 = 0 ;
42970 PyObject * obj4 = 0 ;
42971 PyObject * obj5 = 0 ;
42972 PyObject * obj6 = 0 ;
42973 char *kwnames[] = {
42974 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42975 };
42976
42977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42979 if (SWIG_arg_fail(1)) SWIG_fail;
42980 arg2 = obj1;
42981 {
42982 arg3 = &temp3;
42983 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42984 }
42985 if (obj3) {
42986 {
42987 arg4 = &temp4;
42988 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42989 }
42990 }
42991 if (obj4) {
42992 {
42993 arg5 = (int)(SWIG_As_int(obj4));
42994 if (SWIG_arg_fail(5)) SWIG_fail;
42995 }
42996 }
42997 if (obj5) {
42998 {
42999 arg6 = (int)(SWIG_As_int(obj5));
43000 if (SWIG_arg_fail(6)) SWIG_fail;
43001 }
43002 }
43003 if (obj6) {
43004 arg7 = obj6;
43005 }
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj;
43022 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43023 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43024 wxGBSizerItem *result;
43025 PyObject * obj0 = 0 ;
43026 PyObject * obj1 = 0 ;
43027 char *kwnames[] = {
43028 (char *) "self",(char *) "item", NULL
43029 };
43030
43031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43033 if (SWIG_arg_fail(1)) SWIG_fail;
43034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43035 if (SWIG_arg_fail(2)) SWIG_fail;
43036 {
43037 PyThreadState* __tstate = wxPyBeginAllowThreads();
43038 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43039
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43051 PyObject *resultobj;
43052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43053 int arg2 ;
43054 int arg3 ;
43055 wxSize result;
43056 PyObject * obj0 = 0 ;
43057 PyObject * obj1 = 0 ;
43058 PyObject * obj2 = 0 ;
43059 char *kwnames[] = {
43060 (char *) "self",(char *) "row",(char *) "col", NULL
43061 };
43062
43063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43065 if (SWIG_arg_fail(1)) SWIG_fail;
43066 {
43067 arg2 = (int)(SWIG_As_int(obj1));
43068 if (SWIG_arg_fail(2)) SWIG_fail;
43069 }
43070 {
43071 arg3 = (int)(SWIG_As_int(obj2));
43072 if (SWIG_arg_fail(3)) SWIG_fail;
43073 }
43074 {
43075 PyThreadState* __tstate = wxPyBeginAllowThreads();
43076 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43077
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 {
43082 wxSize * resultptr;
43083 resultptr = new wxSize((wxSize &)(result));
43084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43085 }
43086 return resultobj;
43087 fail:
43088 return NULL;
43089 }
43090
43091
43092 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43093 PyObject *resultobj;
43094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43095 wxSize result;
43096 PyObject * obj0 = 0 ;
43097 char *kwnames[] = {
43098 (char *) "self", NULL
43099 };
43100
43101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43103 if (SWIG_arg_fail(1)) SWIG_fail;
43104 {
43105 PyThreadState* __tstate = wxPyBeginAllowThreads();
43106 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43107
43108 wxPyEndAllowThreads(__tstate);
43109 if (PyErr_Occurred()) SWIG_fail;
43110 }
43111 {
43112 wxSize * resultptr;
43113 resultptr = new wxSize((wxSize &)(result));
43114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43115 }
43116 return resultobj;
43117 fail:
43118 return NULL;
43119 }
43120
43121
43122 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43123 PyObject *resultobj;
43124 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43125 wxSize *arg2 = 0 ;
43126 wxSize temp2 ;
43127 PyObject * obj0 = 0 ;
43128 PyObject * obj1 = 0 ;
43129 char *kwnames[] = {
43130 (char *) "self",(char *) "sz", NULL
43131 };
43132
43133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43135 if (SWIG_arg_fail(1)) SWIG_fail;
43136 {
43137 arg2 = &temp2;
43138 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43139 }
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43143
43144 wxPyEndAllowThreads(__tstate);
43145 if (PyErr_Occurred()) SWIG_fail;
43146 }
43147 Py_INCREF(Py_None); resultobj = Py_None;
43148 return resultobj;
43149 fail:
43150 return NULL;
43151 }
43152
43153
43154 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43155 PyObject *resultobj;
43156 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43157 wxWindow *arg2 = (wxWindow *) 0 ;
43158 wxGBPosition result;
43159 PyObject * obj0 = 0 ;
43160 PyObject * obj1 = 0 ;
43161
43162 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43164 if (SWIG_arg_fail(1)) SWIG_fail;
43165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43166 if (SWIG_arg_fail(2)) SWIG_fail;
43167 {
43168 PyThreadState* __tstate = wxPyBeginAllowThreads();
43169 result = (arg1)->GetItemPosition(arg2);
43170
43171 wxPyEndAllowThreads(__tstate);
43172 if (PyErr_Occurred()) SWIG_fail;
43173 }
43174 {
43175 wxGBPosition * resultptr;
43176 resultptr = new wxGBPosition((wxGBPosition &)(result));
43177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43178 }
43179 return resultobj;
43180 fail:
43181 return NULL;
43182 }
43183
43184
43185 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43186 PyObject *resultobj;
43187 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43188 wxSizer *arg2 = (wxSizer *) 0 ;
43189 wxGBPosition result;
43190 PyObject * obj0 = 0 ;
43191 PyObject * obj1 = 0 ;
43192
43193 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43195 if (SWIG_arg_fail(1)) SWIG_fail;
43196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43197 if (SWIG_arg_fail(2)) SWIG_fail;
43198 {
43199 PyThreadState* __tstate = wxPyBeginAllowThreads();
43200 result = (arg1)->GetItemPosition(arg2);
43201
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 {
43206 wxGBPosition * resultptr;
43207 resultptr = new wxGBPosition((wxGBPosition &)(result));
43208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43209 }
43210 return resultobj;
43211 fail:
43212 return NULL;
43213 }
43214
43215
43216 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43217 PyObject *resultobj;
43218 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43219 size_t arg2 ;
43220 wxGBPosition result;
43221 PyObject * obj0 = 0 ;
43222 PyObject * obj1 = 0 ;
43223
43224 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43226 if (SWIG_arg_fail(1)) SWIG_fail;
43227 {
43228 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43229 if (SWIG_arg_fail(2)) SWIG_fail;
43230 }
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 result = (arg1)->GetItemPosition(arg2);
43234
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 {
43239 wxGBPosition * resultptr;
43240 resultptr = new wxGBPosition((wxGBPosition &)(result));
43241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43242 }
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43250 int argc;
43251 PyObject *argv[3];
43252 int ii;
43253
43254 argc = PyObject_Length(args);
43255 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43256 argv[ii] = PyTuple_GetItem(args,ii);
43257 }
43258 if (argc == 2) {
43259 int _v;
43260 {
43261 void *ptr;
43262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43263 _v = 0;
43264 PyErr_Clear();
43265 } else {
43266 _v = 1;
43267 }
43268 }
43269 if (_v) {
43270 {
43271 void *ptr;
43272 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43273 _v = 0;
43274 PyErr_Clear();
43275 } else {
43276 _v = 1;
43277 }
43278 }
43279 if (_v) {
43280 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43281 }
43282 }
43283 }
43284 if (argc == 2) {
43285 int _v;
43286 {
43287 void *ptr;
43288 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43289 _v = 0;
43290 PyErr_Clear();
43291 } else {
43292 _v = 1;
43293 }
43294 }
43295 if (_v) {
43296 {
43297 void *ptr;
43298 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43299 _v = 0;
43300 PyErr_Clear();
43301 } else {
43302 _v = 1;
43303 }
43304 }
43305 if (_v) {
43306 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43307 }
43308 }
43309 }
43310 if (argc == 2) {
43311 int _v;
43312 {
43313 void *ptr;
43314 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43315 _v = 0;
43316 PyErr_Clear();
43317 } else {
43318 _v = 1;
43319 }
43320 }
43321 if (_v) {
43322 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43323 if (_v) {
43324 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43325 }
43326 }
43327 }
43328
43329 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43330 return NULL;
43331 }
43332
43333
43334 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43335 PyObject *resultobj;
43336 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43337 wxWindow *arg2 = (wxWindow *) 0 ;
43338 wxGBPosition *arg3 = 0 ;
43339 bool result;
43340 wxGBPosition temp3 ;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 PyObject * obj2 = 0 ;
43344
43345 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43347 if (SWIG_arg_fail(1)) SWIG_fail;
43348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43349 if (SWIG_arg_fail(2)) SWIG_fail;
43350 {
43351 arg3 = &temp3;
43352 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43353 }
43354 {
43355 PyThreadState* __tstate = wxPyBeginAllowThreads();
43356 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43357
43358 wxPyEndAllowThreads(__tstate);
43359 if (PyErr_Occurred()) SWIG_fail;
43360 }
43361 {
43362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43363 }
43364 return resultobj;
43365 fail:
43366 return NULL;
43367 }
43368
43369
43370 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43371 PyObject *resultobj;
43372 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43373 wxSizer *arg2 = (wxSizer *) 0 ;
43374 wxGBPosition *arg3 = 0 ;
43375 bool result;
43376 wxGBPosition temp3 ;
43377 PyObject * obj0 = 0 ;
43378 PyObject * obj1 = 0 ;
43379 PyObject * obj2 = 0 ;
43380
43381 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43383 if (SWIG_arg_fail(1)) SWIG_fail;
43384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43385 if (SWIG_arg_fail(2)) SWIG_fail;
43386 {
43387 arg3 = &temp3;
43388 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43389 }
43390 {
43391 PyThreadState* __tstate = wxPyBeginAllowThreads();
43392 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43393
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 {
43398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43399 }
43400 return resultobj;
43401 fail:
43402 return NULL;
43403 }
43404
43405
43406 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43407 PyObject *resultobj;
43408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43409 size_t arg2 ;
43410 wxGBPosition *arg3 = 0 ;
43411 bool result;
43412 wxGBPosition temp3 ;
43413 PyObject * obj0 = 0 ;
43414 PyObject * obj1 = 0 ;
43415 PyObject * obj2 = 0 ;
43416
43417 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43419 if (SWIG_arg_fail(1)) SWIG_fail;
43420 {
43421 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43422 if (SWIG_arg_fail(2)) SWIG_fail;
43423 }
43424 {
43425 arg3 = &temp3;
43426 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43427 }
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43431
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 {
43436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43437 }
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43445 int argc;
43446 PyObject *argv[4];
43447 int ii;
43448
43449 argc = PyObject_Length(args);
43450 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43451 argv[ii] = PyTuple_GetItem(args,ii);
43452 }
43453 if (argc == 3) {
43454 int _v;
43455 {
43456 void *ptr;
43457 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43458 _v = 0;
43459 PyErr_Clear();
43460 } else {
43461 _v = 1;
43462 }
43463 }
43464 if (_v) {
43465 {
43466 void *ptr;
43467 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43468 _v = 0;
43469 PyErr_Clear();
43470 } else {
43471 _v = 1;
43472 }
43473 }
43474 if (_v) {
43475 {
43476 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43477 }
43478 if (_v) {
43479 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43480 }
43481 }
43482 }
43483 }
43484 if (argc == 3) {
43485 int _v;
43486 {
43487 void *ptr;
43488 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43489 _v = 0;
43490 PyErr_Clear();
43491 } else {
43492 _v = 1;
43493 }
43494 }
43495 if (_v) {
43496 {
43497 void *ptr;
43498 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43499 _v = 0;
43500 PyErr_Clear();
43501 } else {
43502 _v = 1;
43503 }
43504 }
43505 if (_v) {
43506 {
43507 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43508 }
43509 if (_v) {
43510 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43511 }
43512 }
43513 }
43514 }
43515 if (argc == 3) {
43516 int _v;
43517 {
43518 void *ptr;
43519 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43520 _v = 0;
43521 PyErr_Clear();
43522 } else {
43523 _v = 1;
43524 }
43525 }
43526 if (_v) {
43527 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43528 if (_v) {
43529 {
43530 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43531 }
43532 if (_v) {
43533 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43534 }
43535 }
43536 }
43537 }
43538
43539 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43540 return NULL;
43541 }
43542
43543
43544 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43545 PyObject *resultobj;
43546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43547 wxWindow *arg2 = (wxWindow *) 0 ;
43548 wxGBSpan result;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551
43552 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43554 if (SWIG_arg_fail(1)) SWIG_fail;
43555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43556 if (SWIG_arg_fail(2)) SWIG_fail;
43557 {
43558 PyThreadState* __tstate = wxPyBeginAllowThreads();
43559 result = (arg1)->GetItemSpan(arg2);
43560
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 {
43565 wxGBSpan * resultptr;
43566 resultptr = new wxGBSpan((wxGBSpan &)(result));
43567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43568 }
43569 return resultobj;
43570 fail:
43571 return NULL;
43572 }
43573
43574
43575 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43576 PyObject *resultobj;
43577 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43578 wxSizer *arg2 = (wxSizer *) 0 ;
43579 wxGBSpan result;
43580 PyObject * obj0 = 0 ;
43581 PyObject * obj1 = 0 ;
43582
43583 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43585 if (SWIG_arg_fail(1)) SWIG_fail;
43586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43587 if (SWIG_arg_fail(2)) SWIG_fail;
43588 {
43589 PyThreadState* __tstate = wxPyBeginAllowThreads();
43590 result = (arg1)->GetItemSpan(arg2);
43591
43592 wxPyEndAllowThreads(__tstate);
43593 if (PyErr_Occurred()) SWIG_fail;
43594 }
43595 {
43596 wxGBSpan * resultptr;
43597 resultptr = new wxGBSpan((wxGBSpan &)(result));
43598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43599 }
43600 return resultobj;
43601 fail:
43602 return NULL;
43603 }
43604
43605
43606 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43607 PyObject *resultobj;
43608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43609 size_t arg2 ;
43610 wxGBSpan result;
43611 PyObject * obj0 = 0 ;
43612 PyObject * obj1 = 0 ;
43613
43614 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43616 if (SWIG_arg_fail(1)) SWIG_fail;
43617 {
43618 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43619 if (SWIG_arg_fail(2)) SWIG_fail;
43620 }
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 result = (arg1)->GetItemSpan(arg2);
43624
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 {
43629 wxGBSpan * resultptr;
43630 resultptr = new wxGBSpan((wxGBSpan &)(result));
43631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43632 }
43633 return resultobj;
43634 fail:
43635 return NULL;
43636 }
43637
43638
43639 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43640 int argc;
43641 PyObject *argv[3];
43642 int ii;
43643
43644 argc = PyObject_Length(args);
43645 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43646 argv[ii] = PyTuple_GetItem(args,ii);
43647 }
43648 if (argc == 2) {
43649 int _v;
43650 {
43651 void *ptr;
43652 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43653 _v = 0;
43654 PyErr_Clear();
43655 } else {
43656 _v = 1;
43657 }
43658 }
43659 if (_v) {
43660 {
43661 void *ptr;
43662 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43663 _v = 0;
43664 PyErr_Clear();
43665 } else {
43666 _v = 1;
43667 }
43668 }
43669 if (_v) {
43670 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43671 }
43672 }
43673 }
43674 if (argc == 2) {
43675 int _v;
43676 {
43677 void *ptr;
43678 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43679 _v = 0;
43680 PyErr_Clear();
43681 } else {
43682 _v = 1;
43683 }
43684 }
43685 if (_v) {
43686 {
43687 void *ptr;
43688 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43689 _v = 0;
43690 PyErr_Clear();
43691 } else {
43692 _v = 1;
43693 }
43694 }
43695 if (_v) {
43696 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43697 }
43698 }
43699 }
43700 if (argc == 2) {
43701 int _v;
43702 {
43703 void *ptr;
43704 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43705 _v = 0;
43706 PyErr_Clear();
43707 } else {
43708 _v = 1;
43709 }
43710 }
43711 if (_v) {
43712 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43713 if (_v) {
43714 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43715 }
43716 }
43717 }
43718
43719 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43720 return NULL;
43721 }
43722
43723
43724 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43725 PyObject *resultobj;
43726 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43727 wxWindow *arg2 = (wxWindow *) 0 ;
43728 wxGBSpan *arg3 = 0 ;
43729 bool result;
43730 wxGBSpan temp3 ;
43731 PyObject * obj0 = 0 ;
43732 PyObject * obj1 = 0 ;
43733 PyObject * obj2 = 0 ;
43734
43735 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43737 if (SWIG_arg_fail(1)) SWIG_fail;
43738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43739 if (SWIG_arg_fail(2)) SWIG_fail;
43740 {
43741 arg3 = &temp3;
43742 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43743 }
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43747
43748 wxPyEndAllowThreads(__tstate);
43749 if (PyErr_Occurred()) SWIG_fail;
43750 }
43751 {
43752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43753 }
43754 return resultobj;
43755 fail:
43756 return NULL;
43757 }
43758
43759
43760 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43761 PyObject *resultobj;
43762 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43763 wxSizer *arg2 = (wxSizer *) 0 ;
43764 wxGBSpan *arg3 = 0 ;
43765 bool result;
43766 wxGBSpan temp3 ;
43767 PyObject * obj0 = 0 ;
43768 PyObject * obj1 = 0 ;
43769 PyObject * obj2 = 0 ;
43770
43771 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43773 if (SWIG_arg_fail(1)) SWIG_fail;
43774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43775 if (SWIG_arg_fail(2)) SWIG_fail;
43776 {
43777 arg3 = &temp3;
43778 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43779 }
43780 {
43781 PyThreadState* __tstate = wxPyBeginAllowThreads();
43782 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43783
43784 wxPyEndAllowThreads(__tstate);
43785 if (PyErr_Occurred()) SWIG_fail;
43786 }
43787 {
43788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43789 }
43790 return resultobj;
43791 fail:
43792 return NULL;
43793 }
43794
43795
43796 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43797 PyObject *resultobj;
43798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43799 size_t arg2 ;
43800 wxGBSpan *arg3 = 0 ;
43801 bool result;
43802 wxGBSpan temp3 ;
43803 PyObject * obj0 = 0 ;
43804 PyObject * obj1 = 0 ;
43805 PyObject * obj2 = 0 ;
43806
43807 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43809 if (SWIG_arg_fail(1)) SWIG_fail;
43810 {
43811 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43812 if (SWIG_arg_fail(2)) SWIG_fail;
43813 }
43814 {
43815 arg3 = &temp3;
43816 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43817 }
43818 {
43819 PyThreadState* __tstate = wxPyBeginAllowThreads();
43820 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43821
43822 wxPyEndAllowThreads(__tstate);
43823 if (PyErr_Occurred()) SWIG_fail;
43824 }
43825 {
43826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43827 }
43828 return resultobj;
43829 fail:
43830 return NULL;
43831 }
43832
43833
43834 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43835 int argc;
43836 PyObject *argv[4];
43837 int ii;
43838
43839 argc = PyObject_Length(args);
43840 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43841 argv[ii] = PyTuple_GetItem(args,ii);
43842 }
43843 if (argc == 3) {
43844 int _v;
43845 {
43846 void *ptr;
43847 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43848 _v = 0;
43849 PyErr_Clear();
43850 } else {
43851 _v = 1;
43852 }
43853 }
43854 if (_v) {
43855 {
43856 void *ptr;
43857 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43858 _v = 0;
43859 PyErr_Clear();
43860 } else {
43861 _v = 1;
43862 }
43863 }
43864 if (_v) {
43865 {
43866 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43867 }
43868 if (_v) {
43869 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43870 }
43871 }
43872 }
43873 }
43874 if (argc == 3) {
43875 int _v;
43876 {
43877 void *ptr;
43878 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43879 _v = 0;
43880 PyErr_Clear();
43881 } else {
43882 _v = 1;
43883 }
43884 }
43885 if (_v) {
43886 {
43887 void *ptr;
43888 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43889 _v = 0;
43890 PyErr_Clear();
43891 } else {
43892 _v = 1;
43893 }
43894 }
43895 if (_v) {
43896 {
43897 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43898 }
43899 if (_v) {
43900 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43901 }
43902 }
43903 }
43904 }
43905 if (argc == 3) {
43906 int _v;
43907 {
43908 void *ptr;
43909 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43910 _v = 0;
43911 PyErr_Clear();
43912 } else {
43913 _v = 1;
43914 }
43915 }
43916 if (_v) {
43917 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43918 if (_v) {
43919 {
43920 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43921 }
43922 if (_v) {
43923 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43924 }
43925 }
43926 }
43927 }
43928
43929 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43930 return NULL;
43931 }
43932
43933
43934 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43935 PyObject *resultobj;
43936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43937 wxWindow *arg2 = (wxWindow *) 0 ;
43938 wxGBSizerItem *result;
43939 PyObject * obj0 = 0 ;
43940 PyObject * obj1 = 0 ;
43941
43942 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43944 if (SWIG_arg_fail(1)) SWIG_fail;
43945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43946 if (SWIG_arg_fail(2)) SWIG_fail;
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43950
43951 wxPyEndAllowThreads(__tstate);
43952 if (PyErr_Occurred()) SWIG_fail;
43953 }
43954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43955 return resultobj;
43956 fail:
43957 return NULL;
43958 }
43959
43960
43961 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43962 PyObject *resultobj;
43963 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43964 wxSizer *arg2 = (wxSizer *) 0 ;
43965 wxGBSizerItem *result;
43966 PyObject * obj0 = 0 ;
43967 PyObject * obj1 = 0 ;
43968
43969 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43971 if (SWIG_arg_fail(1)) SWIG_fail;
43972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43973 if (SWIG_arg_fail(2)) SWIG_fail;
43974 {
43975 PyThreadState* __tstate = wxPyBeginAllowThreads();
43976 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43977
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43989 int argc;
43990 PyObject *argv[3];
43991 int ii;
43992
43993 argc = PyObject_Length(args);
43994 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43995 argv[ii] = PyTuple_GetItem(args,ii);
43996 }
43997 if (argc == 2) {
43998 int _v;
43999 {
44000 void *ptr;
44001 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44002 _v = 0;
44003 PyErr_Clear();
44004 } else {
44005 _v = 1;
44006 }
44007 }
44008 if (_v) {
44009 {
44010 void *ptr;
44011 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44012 _v = 0;
44013 PyErr_Clear();
44014 } else {
44015 _v = 1;
44016 }
44017 }
44018 if (_v) {
44019 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44020 }
44021 }
44022 }
44023 if (argc == 2) {
44024 int _v;
44025 {
44026 void *ptr;
44027 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44028 _v = 0;
44029 PyErr_Clear();
44030 } else {
44031 _v = 1;
44032 }
44033 }
44034 if (_v) {
44035 {
44036 void *ptr;
44037 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44038 _v = 0;
44039 PyErr_Clear();
44040 } else {
44041 _v = 1;
44042 }
44043 }
44044 if (_v) {
44045 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44046 }
44047 }
44048 }
44049
44050 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44051 return NULL;
44052 }
44053
44054
44055 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44056 PyObject *resultobj;
44057 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44058 wxGBPosition *arg2 = 0 ;
44059 wxGBSizerItem *result;
44060 wxGBPosition temp2 ;
44061 PyObject * obj0 = 0 ;
44062 PyObject * obj1 = 0 ;
44063 char *kwnames[] = {
44064 (char *) "self",(char *) "pos", NULL
44065 };
44066
44067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44069 if (SWIG_arg_fail(1)) SWIG_fail;
44070 {
44071 arg2 = &temp2;
44072 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44073 }
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44077
44078 wxPyEndAllowThreads(__tstate);
44079 if (PyErr_Occurred()) SWIG_fail;
44080 }
44081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44082 return resultobj;
44083 fail:
44084 return NULL;
44085 }
44086
44087
44088 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44089 PyObject *resultobj;
44090 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44091 wxPoint *arg2 = 0 ;
44092 wxGBSizerItem *result;
44093 wxPoint temp2 ;
44094 PyObject * obj0 = 0 ;
44095 PyObject * obj1 = 0 ;
44096 char *kwnames[] = {
44097 (char *) "self",(char *) "pt", NULL
44098 };
44099
44100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44102 if (SWIG_arg_fail(1)) SWIG_fail;
44103 {
44104 arg2 = &temp2;
44105 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44106 }
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44110
44111 wxPyEndAllowThreads(__tstate);
44112 if (PyErr_Occurred()) SWIG_fail;
44113 }
44114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44115 return resultobj;
44116 fail:
44117 return NULL;
44118 }
44119
44120
44121 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44122 PyObject *resultobj;
44123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44124 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44125 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44126 bool result;
44127 PyObject * obj0 = 0 ;
44128 PyObject * obj1 = 0 ;
44129 PyObject * obj2 = 0 ;
44130 char *kwnames[] = {
44131 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44132 };
44133
44134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44136 if (SWIG_arg_fail(1)) SWIG_fail;
44137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44138 if (SWIG_arg_fail(2)) SWIG_fail;
44139 if (obj2) {
44140 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44141 if (SWIG_arg_fail(3)) SWIG_fail;
44142 }
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44146
44147 wxPyEndAllowThreads(__tstate);
44148 if (PyErr_Occurred()) SWIG_fail;
44149 }
44150 {
44151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44152 }
44153 return resultobj;
44154 fail:
44155 return NULL;
44156 }
44157
44158
44159 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44160 PyObject *resultobj;
44161 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44162 wxGBPosition *arg2 = 0 ;
44163 wxGBSpan *arg3 = 0 ;
44164 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44165 bool result;
44166 wxGBPosition temp2 ;
44167 wxGBSpan temp3 ;
44168 PyObject * obj0 = 0 ;
44169 PyObject * obj1 = 0 ;
44170 PyObject * obj2 = 0 ;
44171 PyObject * obj3 = 0 ;
44172 char *kwnames[] = {
44173 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44174 };
44175
44176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44178 if (SWIG_arg_fail(1)) SWIG_fail;
44179 {
44180 arg2 = &temp2;
44181 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44182 }
44183 {
44184 arg3 = &temp3;
44185 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44186 }
44187 if (obj3) {
44188 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44189 if (SWIG_arg_fail(4)) SWIG_fail;
44190 }
44191 {
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44194
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 {
44199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44200 }
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44208 PyObject *obj;
44209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44210 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44211 Py_INCREF(obj);
44212 return Py_BuildValue((char *)"");
44213 }
44214 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44215 PyObject *resultobj;
44216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44217 wxRelationship arg2 ;
44218 wxWindow *arg3 = (wxWindow *) 0 ;
44219 wxEdge arg4 ;
44220 int arg5 = (int) 0 ;
44221 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44222 PyObject * obj0 = 0 ;
44223 PyObject * obj1 = 0 ;
44224 PyObject * obj2 = 0 ;
44225 PyObject * obj3 = 0 ;
44226 PyObject * obj4 = 0 ;
44227 PyObject * obj5 = 0 ;
44228 char *kwnames[] = {
44229 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44230 };
44231
44232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44234 if (SWIG_arg_fail(1)) SWIG_fail;
44235 {
44236 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44237 if (SWIG_arg_fail(2)) SWIG_fail;
44238 }
44239 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44240 if (SWIG_arg_fail(3)) SWIG_fail;
44241 {
44242 arg4 = (wxEdge)(SWIG_As_int(obj3));
44243 if (SWIG_arg_fail(4)) SWIG_fail;
44244 }
44245 if (obj4) {
44246 {
44247 arg5 = (int)(SWIG_As_int(obj4));
44248 if (SWIG_arg_fail(5)) SWIG_fail;
44249 }
44250 }
44251 if (obj5) {
44252 {
44253 arg6 = (int)(SWIG_As_int(obj5));
44254 if (SWIG_arg_fail(6)) SWIG_fail;
44255 }
44256 }
44257 {
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44260
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 Py_INCREF(Py_None); resultobj = Py_None;
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44272 PyObject *resultobj;
44273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44274 wxWindow *arg2 = (wxWindow *) 0 ;
44275 int arg3 = (int) 0 ;
44276 PyObject * obj0 = 0 ;
44277 PyObject * obj1 = 0 ;
44278 PyObject * obj2 = 0 ;
44279 char *kwnames[] = {
44280 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44281 };
44282
44283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) 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 if (obj2) {
44289 {
44290 arg3 = (int)(SWIG_As_int(obj2));
44291 if (SWIG_arg_fail(3)) SWIG_fail;
44292 }
44293 }
44294 {
44295 PyThreadState* __tstate = wxPyBeginAllowThreads();
44296 (arg1)->LeftOf(arg2,arg3);
44297
44298 wxPyEndAllowThreads(__tstate);
44299 if (PyErr_Occurred()) SWIG_fail;
44300 }
44301 Py_INCREF(Py_None); resultobj = Py_None;
44302 return resultobj;
44303 fail:
44304 return NULL;
44305 }
44306
44307
44308 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44309 PyObject *resultobj;
44310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44311 wxWindow *arg2 = (wxWindow *) 0 ;
44312 int arg3 = (int) 0 ;
44313 PyObject * obj0 = 0 ;
44314 PyObject * obj1 = 0 ;
44315 PyObject * obj2 = 0 ;
44316 char *kwnames[] = {
44317 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44318 };
44319
44320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44322 if (SWIG_arg_fail(1)) SWIG_fail;
44323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44324 if (SWIG_arg_fail(2)) SWIG_fail;
44325 if (obj2) {
44326 {
44327 arg3 = (int)(SWIG_As_int(obj2));
44328 if (SWIG_arg_fail(3)) SWIG_fail;
44329 }
44330 }
44331 {
44332 PyThreadState* __tstate = wxPyBeginAllowThreads();
44333 (arg1)->RightOf(arg2,arg3);
44334
44335 wxPyEndAllowThreads(__tstate);
44336 if (PyErr_Occurred()) SWIG_fail;
44337 }
44338 Py_INCREF(Py_None); resultobj = Py_None;
44339 return resultobj;
44340 fail:
44341 return NULL;
44342 }
44343
44344
44345 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44346 PyObject *resultobj;
44347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44348 wxWindow *arg2 = (wxWindow *) 0 ;
44349 int arg3 = (int) 0 ;
44350 PyObject * obj0 = 0 ;
44351 PyObject * obj1 = 0 ;
44352 PyObject * obj2 = 0 ;
44353 char *kwnames[] = {
44354 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44355 };
44356
44357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44359 if (SWIG_arg_fail(1)) SWIG_fail;
44360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44361 if (SWIG_arg_fail(2)) SWIG_fail;
44362 if (obj2) {
44363 {
44364 arg3 = (int)(SWIG_As_int(obj2));
44365 if (SWIG_arg_fail(3)) SWIG_fail;
44366 }
44367 }
44368 {
44369 PyThreadState* __tstate = wxPyBeginAllowThreads();
44370 (arg1)->Above(arg2,arg3);
44371
44372 wxPyEndAllowThreads(__tstate);
44373 if (PyErr_Occurred()) SWIG_fail;
44374 }
44375 Py_INCREF(Py_None); resultobj = Py_None;
44376 return resultobj;
44377 fail:
44378 return NULL;
44379 }
44380
44381
44382 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44383 PyObject *resultobj;
44384 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44385 wxWindow *arg2 = (wxWindow *) 0 ;
44386 int arg3 = (int) 0 ;
44387 PyObject * obj0 = 0 ;
44388 PyObject * obj1 = 0 ;
44389 PyObject * obj2 = 0 ;
44390 char *kwnames[] = {
44391 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44392 };
44393
44394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44396 if (SWIG_arg_fail(1)) SWIG_fail;
44397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44398 if (SWIG_arg_fail(2)) SWIG_fail;
44399 if (obj2) {
44400 {
44401 arg3 = (int)(SWIG_As_int(obj2));
44402 if (SWIG_arg_fail(3)) SWIG_fail;
44403 }
44404 }
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 (arg1)->Below(arg2,arg3);
44408
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 Py_INCREF(Py_None); resultobj = Py_None;
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44420 PyObject *resultobj;
44421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44422 wxWindow *arg2 = (wxWindow *) 0 ;
44423 wxEdge arg3 ;
44424 int arg4 = (int) 0 ;
44425 PyObject * obj0 = 0 ;
44426 PyObject * obj1 = 0 ;
44427 PyObject * obj2 = 0 ;
44428 PyObject * obj3 = 0 ;
44429 char *kwnames[] = {
44430 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44431 };
44432
44433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44435 if (SWIG_arg_fail(1)) SWIG_fail;
44436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44437 if (SWIG_arg_fail(2)) SWIG_fail;
44438 {
44439 arg3 = (wxEdge)(SWIG_As_int(obj2));
44440 if (SWIG_arg_fail(3)) SWIG_fail;
44441 }
44442 if (obj3) {
44443 {
44444 arg4 = (int)(SWIG_As_int(obj3));
44445 if (SWIG_arg_fail(4)) SWIG_fail;
44446 }
44447 }
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44451
44452 wxPyEndAllowThreads(__tstate);
44453 if (PyErr_Occurred()) SWIG_fail;
44454 }
44455 Py_INCREF(Py_None); resultobj = Py_None;
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj;
44464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44465 wxWindow *arg2 = (wxWindow *) 0 ;
44466 wxEdge arg3 ;
44467 int arg4 ;
44468 PyObject * obj0 = 0 ;
44469 PyObject * obj1 = 0 ;
44470 PyObject * obj2 = 0 ;
44471 PyObject * obj3 = 0 ;
44472 char *kwnames[] = {
44473 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44474 };
44475
44476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44478 if (SWIG_arg_fail(1)) SWIG_fail;
44479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44480 if (SWIG_arg_fail(2)) SWIG_fail;
44481 {
44482 arg3 = (wxEdge)(SWIG_As_int(obj2));
44483 if (SWIG_arg_fail(3)) SWIG_fail;
44484 }
44485 {
44486 arg4 = (int)(SWIG_As_int(obj3));
44487 if (SWIG_arg_fail(4)) SWIG_fail;
44488 }
44489 {
44490 PyThreadState* __tstate = wxPyBeginAllowThreads();
44491 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44492
44493 wxPyEndAllowThreads(__tstate);
44494 if (PyErr_Occurred()) SWIG_fail;
44495 }
44496 Py_INCREF(Py_None); resultobj = Py_None;
44497 return resultobj;
44498 fail:
44499 return NULL;
44500 }
44501
44502
44503 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj;
44505 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44506 int arg2 ;
44507 PyObject * obj0 = 0 ;
44508 PyObject * obj1 = 0 ;
44509 char *kwnames[] = {
44510 (char *) "self",(char *) "val", NULL
44511 };
44512
44513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44515 if (SWIG_arg_fail(1)) SWIG_fail;
44516 {
44517 arg2 = (int)(SWIG_As_int(obj1));
44518 if (SWIG_arg_fail(2)) SWIG_fail;
44519 }
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 (arg1)->Absolute(arg2);
44523
44524 wxPyEndAllowThreads(__tstate);
44525 if (PyErr_Occurred()) SWIG_fail;
44526 }
44527 Py_INCREF(Py_None); resultobj = Py_None;
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44535 PyObject *resultobj;
44536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44537 PyObject * obj0 = 0 ;
44538 char *kwnames[] = {
44539 (char *) "self", NULL
44540 };
44541
44542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44544 if (SWIG_arg_fail(1)) SWIG_fail;
44545 {
44546 PyThreadState* __tstate = wxPyBeginAllowThreads();
44547 (arg1)->Unconstrained();
44548
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 Py_INCREF(Py_None); resultobj = Py_None;
44553 return resultobj;
44554 fail:
44555 return NULL;
44556 }
44557
44558
44559 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44560 PyObject *resultobj;
44561 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44562 PyObject * obj0 = 0 ;
44563 char *kwnames[] = {
44564 (char *) "self", NULL
44565 };
44566
44567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44569 if (SWIG_arg_fail(1)) SWIG_fail;
44570 {
44571 PyThreadState* __tstate = wxPyBeginAllowThreads();
44572 (arg1)->AsIs();
44573
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 Py_INCREF(Py_None); resultobj = Py_None;
44578 return resultobj;
44579 fail:
44580 return NULL;
44581 }
44582
44583
44584 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44585 PyObject *resultobj;
44586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44587 wxWindow *result;
44588 PyObject * obj0 = 0 ;
44589 char *kwnames[] = {
44590 (char *) "self", NULL
44591 };
44592
44593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44595 if (SWIG_arg_fail(1)) SWIG_fail;
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = (wxWindow *)(arg1)->GetOtherWindow();
44599
44600 wxPyEndAllowThreads(__tstate);
44601 if (PyErr_Occurred()) SWIG_fail;
44602 }
44603 {
44604 resultobj = wxPyMake_wxObject(result, 0);
44605 }
44606 return resultobj;
44607 fail:
44608 return NULL;
44609 }
44610
44611
44612 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44613 PyObject *resultobj;
44614 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44615 wxEdge result;
44616 PyObject * obj0 = 0 ;
44617 char *kwnames[] = {
44618 (char *) "self", NULL
44619 };
44620
44621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44623 if (SWIG_arg_fail(1)) SWIG_fail;
44624 {
44625 PyThreadState* __tstate = wxPyBeginAllowThreads();
44626 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44627
44628 wxPyEndAllowThreads(__tstate);
44629 if (PyErr_Occurred()) SWIG_fail;
44630 }
44631 resultobj = SWIG_From_int((result));
44632 return resultobj;
44633 fail:
44634 return NULL;
44635 }
44636
44637
44638 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44639 PyObject *resultobj;
44640 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44641 wxEdge arg2 ;
44642 PyObject * obj0 = 0 ;
44643 PyObject * obj1 = 0 ;
44644 char *kwnames[] = {
44645 (char *) "self",(char *) "which", NULL
44646 };
44647
44648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44650 if (SWIG_arg_fail(1)) SWIG_fail;
44651 {
44652 arg2 = (wxEdge)(SWIG_As_int(obj1));
44653 if (SWIG_arg_fail(2)) SWIG_fail;
44654 }
44655 {
44656 PyThreadState* __tstate = wxPyBeginAllowThreads();
44657 (arg1)->SetEdge((wxEdge )arg2);
44658
44659 wxPyEndAllowThreads(__tstate);
44660 if (PyErr_Occurred()) SWIG_fail;
44661 }
44662 Py_INCREF(Py_None); resultobj = Py_None;
44663 return resultobj;
44664 fail:
44665 return NULL;
44666 }
44667
44668
44669 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44670 PyObject *resultobj;
44671 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44672 int arg2 ;
44673 PyObject * obj0 = 0 ;
44674 PyObject * obj1 = 0 ;
44675 char *kwnames[] = {
44676 (char *) "self",(char *) "v", NULL
44677 };
44678
44679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44681 if (SWIG_arg_fail(1)) SWIG_fail;
44682 {
44683 arg2 = (int)(SWIG_As_int(obj1));
44684 if (SWIG_arg_fail(2)) SWIG_fail;
44685 }
44686 {
44687 PyThreadState* __tstate = wxPyBeginAllowThreads();
44688 (arg1)->SetValue(arg2);
44689
44690 wxPyEndAllowThreads(__tstate);
44691 if (PyErr_Occurred()) SWIG_fail;
44692 }
44693 Py_INCREF(Py_None); resultobj = Py_None;
44694 return resultobj;
44695 fail:
44696 return NULL;
44697 }
44698
44699
44700 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44701 PyObject *resultobj;
44702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44703 int result;
44704 PyObject * obj0 = 0 ;
44705 char *kwnames[] = {
44706 (char *) "self", NULL
44707 };
44708
44709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44711 if (SWIG_arg_fail(1)) SWIG_fail;
44712 {
44713 PyThreadState* __tstate = wxPyBeginAllowThreads();
44714 result = (int)(arg1)->GetMargin();
44715
44716 wxPyEndAllowThreads(__tstate);
44717 if (PyErr_Occurred()) SWIG_fail;
44718 }
44719 {
44720 resultobj = SWIG_From_int((int)(result));
44721 }
44722 return resultobj;
44723 fail:
44724 return NULL;
44725 }
44726
44727
44728 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44729 PyObject *resultobj;
44730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44731 int arg2 ;
44732 PyObject * obj0 = 0 ;
44733 PyObject * obj1 = 0 ;
44734 char *kwnames[] = {
44735 (char *) "self",(char *) "m", NULL
44736 };
44737
44738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44740 if (SWIG_arg_fail(1)) SWIG_fail;
44741 {
44742 arg2 = (int)(SWIG_As_int(obj1));
44743 if (SWIG_arg_fail(2)) SWIG_fail;
44744 }
44745 {
44746 PyThreadState* __tstate = wxPyBeginAllowThreads();
44747 (arg1)->SetMargin(arg2);
44748
44749 wxPyEndAllowThreads(__tstate);
44750 if (PyErr_Occurred()) SWIG_fail;
44751 }
44752 Py_INCREF(Py_None); resultobj = Py_None;
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44760 PyObject *resultobj;
44761 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44762 int result;
44763 PyObject * obj0 = 0 ;
44764 char *kwnames[] = {
44765 (char *) "self", NULL
44766 };
44767
44768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44770 if (SWIG_arg_fail(1)) SWIG_fail;
44771 {
44772 PyThreadState* __tstate = wxPyBeginAllowThreads();
44773 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44774
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 {
44779 resultobj = SWIG_From_int((int)(result));
44780 }
44781 return resultobj;
44782 fail:
44783 return NULL;
44784 }
44785
44786
44787 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44788 PyObject *resultobj;
44789 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44790 int result;
44791 PyObject * obj0 = 0 ;
44792 char *kwnames[] = {
44793 (char *) "self", NULL
44794 };
44795
44796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44798 if (SWIG_arg_fail(1)) SWIG_fail;
44799 {
44800 PyThreadState* __tstate = wxPyBeginAllowThreads();
44801 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44802
44803 wxPyEndAllowThreads(__tstate);
44804 if (PyErr_Occurred()) SWIG_fail;
44805 }
44806 {
44807 resultobj = SWIG_From_int((int)(result));
44808 }
44809 return resultobj;
44810 fail:
44811 return NULL;
44812 }
44813
44814
44815 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44816 PyObject *resultobj;
44817 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44818 int result;
44819 PyObject * obj0 = 0 ;
44820 char *kwnames[] = {
44821 (char *) "self", NULL
44822 };
44823
44824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44826 if (SWIG_arg_fail(1)) SWIG_fail;
44827 {
44828 PyThreadState* __tstate = wxPyBeginAllowThreads();
44829 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44830
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 {
44835 resultobj = SWIG_From_int((int)(result));
44836 }
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44844 PyObject *resultobj;
44845 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44846 bool result;
44847 PyObject * obj0 = 0 ;
44848 char *kwnames[] = {
44849 (char *) "self", NULL
44850 };
44851
44852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44854 if (SWIG_arg_fail(1)) SWIG_fail;
44855 {
44856 PyThreadState* __tstate = wxPyBeginAllowThreads();
44857 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44858
44859 wxPyEndAllowThreads(__tstate);
44860 if (PyErr_Occurred()) SWIG_fail;
44861 }
44862 {
44863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44864 }
44865 return resultobj;
44866 fail:
44867 return NULL;
44868 }
44869
44870
44871 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44872 PyObject *resultobj;
44873 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44874 bool arg2 ;
44875 PyObject * obj0 = 0 ;
44876 PyObject * obj1 = 0 ;
44877 char *kwnames[] = {
44878 (char *) "self",(char *) "d", NULL
44879 };
44880
44881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44883 if (SWIG_arg_fail(1)) SWIG_fail;
44884 {
44885 arg2 = (bool)(SWIG_As_bool(obj1));
44886 if (SWIG_arg_fail(2)) SWIG_fail;
44887 }
44888 {
44889 PyThreadState* __tstate = wxPyBeginAllowThreads();
44890 (arg1)->SetDone(arg2);
44891
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 Py_INCREF(Py_None); resultobj = Py_None;
44896 return resultobj;
44897 fail:
44898 return NULL;
44899 }
44900
44901
44902 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44903 PyObject *resultobj;
44904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44905 wxRelationship result;
44906 PyObject * obj0 = 0 ;
44907 char *kwnames[] = {
44908 (char *) "self", NULL
44909 };
44910
44911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44913 if (SWIG_arg_fail(1)) SWIG_fail;
44914 {
44915 PyThreadState* __tstate = wxPyBeginAllowThreads();
44916 result = (wxRelationship)(arg1)->GetRelationship();
44917
44918 wxPyEndAllowThreads(__tstate);
44919 if (PyErr_Occurred()) SWIG_fail;
44920 }
44921 resultobj = SWIG_From_int((result));
44922 return resultobj;
44923 fail:
44924 return NULL;
44925 }
44926
44927
44928 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44929 PyObject *resultobj;
44930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44931 wxRelationship arg2 ;
44932 PyObject * obj0 = 0 ;
44933 PyObject * obj1 = 0 ;
44934 char *kwnames[] = {
44935 (char *) "self",(char *) "r", NULL
44936 };
44937
44938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44940 if (SWIG_arg_fail(1)) SWIG_fail;
44941 {
44942 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44943 if (SWIG_arg_fail(2)) SWIG_fail;
44944 }
44945 {
44946 PyThreadState* __tstate = wxPyBeginAllowThreads();
44947 (arg1)->SetRelationship((wxRelationship )arg2);
44948
44949 wxPyEndAllowThreads(__tstate);
44950 if (PyErr_Occurred()) SWIG_fail;
44951 }
44952 Py_INCREF(Py_None); resultobj = Py_None;
44953 return resultobj;
44954 fail:
44955 return NULL;
44956 }
44957
44958
44959 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44960 PyObject *resultobj;
44961 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44962 wxWindow *arg2 = (wxWindow *) 0 ;
44963 bool result;
44964 PyObject * obj0 = 0 ;
44965 PyObject * obj1 = 0 ;
44966 char *kwnames[] = {
44967 (char *) "self",(char *) "otherW", NULL
44968 };
44969
44970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44972 if (SWIG_arg_fail(1)) SWIG_fail;
44973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44974 if (SWIG_arg_fail(2)) SWIG_fail;
44975 {
44976 PyThreadState* __tstate = wxPyBeginAllowThreads();
44977 result = (bool)(arg1)->ResetIfWin(arg2);
44978
44979 wxPyEndAllowThreads(__tstate);
44980 if (PyErr_Occurred()) SWIG_fail;
44981 }
44982 {
44983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44984 }
44985 return resultobj;
44986 fail:
44987 return NULL;
44988 }
44989
44990
44991 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44992 PyObject *resultobj;
44993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44994 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44995 wxWindow *arg3 = (wxWindow *) 0 ;
44996 bool result;
44997 PyObject * obj0 = 0 ;
44998 PyObject * obj1 = 0 ;
44999 PyObject * obj2 = 0 ;
45000 char *kwnames[] = {
45001 (char *) "self",(char *) "constraints",(char *) "win", NULL
45002 };
45003
45004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45006 if (SWIG_arg_fail(1)) SWIG_fail;
45007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45008 if (SWIG_arg_fail(2)) SWIG_fail;
45009 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45010 if (SWIG_arg_fail(3)) SWIG_fail;
45011 {
45012 PyThreadState* __tstate = wxPyBeginAllowThreads();
45013 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45014
45015 wxPyEndAllowThreads(__tstate);
45016 if (PyErr_Occurred()) SWIG_fail;
45017 }
45018 {
45019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45020 }
45021 return resultobj;
45022 fail:
45023 return NULL;
45024 }
45025
45026
45027 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45028 PyObject *resultobj;
45029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45030 wxEdge arg2 ;
45031 wxWindow *arg3 = (wxWindow *) 0 ;
45032 wxWindow *arg4 = (wxWindow *) 0 ;
45033 int result;
45034 PyObject * obj0 = 0 ;
45035 PyObject * obj1 = 0 ;
45036 PyObject * obj2 = 0 ;
45037 PyObject * obj3 = 0 ;
45038 char *kwnames[] = {
45039 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45040 };
45041
45042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45044 if (SWIG_arg_fail(1)) SWIG_fail;
45045 {
45046 arg2 = (wxEdge)(SWIG_As_int(obj1));
45047 if (SWIG_arg_fail(2)) SWIG_fail;
45048 }
45049 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45050 if (SWIG_arg_fail(3)) SWIG_fail;
45051 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45052 if (SWIG_arg_fail(4)) SWIG_fail;
45053 {
45054 PyThreadState* __tstate = wxPyBeginAllowThreads();
45055 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45056
45057 wxPyEndAllowThreads(__tstate);
45058 if (PyErr_Occurred()) SWIG_fail;
45059 }
45060 {
45061 resultobj = SWIG_From_int((int)(result));
45062 }
45063 return resultobj;
45064 fail:
45065 return NULL;
45066 }
45067
45068
45069 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45070 PyObject *obj;
45071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45072 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45073 Py_INCREF(obj);
45074 return Py_BuildValue((char *)"");
45075 }
45076 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45077 PyObject *resultobj;
45078 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45079 wxIndividualLayoutConstraint *result;
45080 PyObject * obj0 = 0 ;
45081 char *kwnames[] = {
45082 (char *) "self", NULL
45083 };
45084
45085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45087 if (SWIG_arg_fail(1)) SWIG_fail;
45088 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45089
45090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj;
45099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45100 wxIndividualLayoutConstraint *result;
45101 PyObject * obj0 = 0 ;
45102 char *kwnames[] = {
45103 (char *) "self", NULL
45104 };
45105
45106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45108 if (SWIG_arg_fail(1)) SWIG_fail;
45109 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45110
45111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj;
45120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45121 wxIndividualLayoutConstraint *result;
45122 PyObject * obj0 = 0 ;
45123 char *kwnames[] = {
45124 (char *) "self", NULL
45125 };
45126
45127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45129 if (SWIG_arg_fail(1)) SWIG_fail;
45130 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45131
45132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj;
45141 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45142 wxIndividualLayoutConstraint *result;
45143 PyObject * obj0 = 0 ;
45144 char *kwnames[] = {
45145 (char *) "self", NULL
45146 };
45147
45148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45150 if (SWIG_arg_fail(1)) SWIG_fail;
45151 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45152
45153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45161 PyObject *resultobj;
45162 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45163 wxIndividualLayoutConstraint *result;
45164 PyObject * obj0 = 0 ;
45165 char *kwnames[] = {
45166 (char *) "self", NULL
45167 };
45168
45169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45171 if (SWIG_arg_fail(1)) SWIG_fail;
45172 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45173
45174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj;
45183 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45184 wxIndividualLayoutConstraint *result;
45185 PyObject * obj0 = 0 ;
45186 char *kwnames[] = {
45187 (char *) "self", NULL
45188 };
45189
45190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45192 if (SWIG_arg_fail(1)) SWIG_fail;
45193 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45194
45195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45196 return resultobj;
45197 fail:
45198 return NULL;
45199 }
45200
45201
45202 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45203 PyObject *resultobj;
45204 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45205 wxIndividualLayoutConstraint *result;
45206 PyObject * obj0 = 0 ;
45207 char *kwnames[] = {
45208 (char *) "self", NULL
45209 };
45210
45211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45213 if (SWIG_arg_fail(1)) SWIG_fail;
45214 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45215
45216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45224 PyObject *resultobj;
45225 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45226 wxIndividualLayoutConstraint *result;
45227 PyObject * obj0 = 0 ;
45228 char *kwnames[] = {
45229 (char *) "self", NULL
45230 };
45231
45232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(1)) SWIG_fail;
45235 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45236
45237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45238 return resultobj;
45239 fail:
45240 return NULL;
45241 }
45242
45243
45244 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45245 PyObject *resultobj;
45246 wxLayoutConstraints *result;
45247 char *kwnames[] = {
45248 NULL
45249 };
45250
45251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45255
45256 wxPyEndAllowThreads(__tstate);
45257 if (PyErr_Occurred()) SWIG_fail;
45258 }
45259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45260 return resultobj;
45261 fail:
45262 return NULL;
45263 }
45264
45265
45266 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45267 PyObject *resultobj;
45268 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45269 wxWindow *arg2 = (wxWindow *) 0 ;
45270 int *arg3 = (int *) 0 ;
45271 bool result;
45272 int temp3 ;
45273 int res3 = 0 ;
45274 PyObject * obj0 = 0 ;
45275 PyObject * obj1 = 0 ;
45276 char *kwnames[] = {
45277 (char *) "self",(char *) "win", NULL
45278 };
45279
45280 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45283 if (SWIG_arg_fail(1)) SWIG_fail;
45284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45285 if (SWIG_arg_fail(2)) SWIG_fail;
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45289
45290 wxPyEndAllowThreads(__tstate);
45291 if (PyErr_Occurred()) SWIG_fail;
45292 }
45293 {
45294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45295 }
45296 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45297 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45298 return resultobj;
45299 fail:
45300 return NULL;
45301 }
45302
45303
45304 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45305 PyObject *resultobj;
45306 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45307 bool result;
45308 PyObject * obj0 = 0 ;
45309 char *kwnames[] = {
45310 (char *) "self", NULL
45311 };
45312
45313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45315 if (SWIG_arg_fail(1)) SWIG_fail;
45316 {
45317 PyThreadState* __tstate = wxPyBeginAllowThreads();
45318 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45319
45320 wxPyEndAllowThreads(__tstate);
45321 if (PyErr_Occurred()) SWIG_fail;
45322 }
45323 {
45324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45325 }
45326 return resultobj;
45327 fail:
45328 return NULL;
45329 }
45330
45331
45332 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45333 PyObject *obj;
45334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45335 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45336 Py_INCREF(obj);
45337 return Py_BuildValue((char *)"");
45338 }
45339 static PyMethodDef SwigMethods[] = {
45340 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45341 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45342 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45345 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45366 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45379 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45394 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45448 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45476 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45495 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45497 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45505 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45506 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45518 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45530 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45534 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45540 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45550 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45567 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45647 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45651 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45653 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45655 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45657 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45659 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45661 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45663 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45665 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45667 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45669 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45671 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45685 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45703 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45706 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45709 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45726 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45732 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45738 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45801 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45808 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45844 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45854 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45860 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45862 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45864 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45871 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45874 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45877 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45879 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45884 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45892 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45896 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45899 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45901 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45905 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45924 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45927 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45929 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45933 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45937 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45948 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45954 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45965 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45970 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45975 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45979 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46024 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46044 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46051 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46055 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46065 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46237 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46279 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46294 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46297 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46352 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46379 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46423 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46431 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46450 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46451 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46488 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46521 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46525 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46528 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46538 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46550 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46562 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46572 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46582 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46596 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46603 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46604 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46605 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46606 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46607 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46612 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46639 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46651 { NULL, NULL, 0, NULL }
46652 };
46653
46654
46655 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46656
46657 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46658 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46659 }
46660 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46661 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46662 }
46663 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46664 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46665 }
46666 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46667 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46668 }
46669 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46670 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46671 }
46672 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46673 return (void *)((wxSizer *) ((wxGridSizer *) x));
46674 }
46675 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46676 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46677 }
46678 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46679 return (void *)((wxSizer *) ((wxPySizer *) x));
46680 }
46681 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46682 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46683 }
46684 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46685 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46686 }
46687 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46688 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46689 }
46690 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46691 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46692 }
46693 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46694 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46695 }
46696 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46697 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46698 }
46699 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46700 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46701 }
46702 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46703 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46704 }
46705 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46706 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46707 }
46708 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46709 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46710 }
46711 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46712 return (void *)((wxEvent *) ((wxPyEvent *) x));
46713 }
46714 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46715 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46716 }
46717 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46718 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46719 }
46720 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46721 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46722 }
46723 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46724 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46725 }
46726 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46727 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46728 }
46729 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46730 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46731 }
46732 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46733 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46734 }
46735 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46736 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46737 }
46738 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46739 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46740 }
46741 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46742 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46743 }
46744 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46745 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46746 }
46747 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46748 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46749 }
46750 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46751 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46752 }
46753 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46754 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46755 }
46756 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46757 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46758 }
46759 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46760 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46761 }
46762 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46763 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46764 }
46765 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46766 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46767 }
46768 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46769 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46770 }
46771 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46773 }
46774 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46775 return (void *)((wxEvent *) ((wxShowEvent *) x));
46776 }
46777 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46778 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46779 }
46780 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46781 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46782 }
46783 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46784 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46785 }
46786 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46787 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46788 }
46789 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46790 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46791 }
46792 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46793 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46794 }
46795 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46796 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46797 }
46798 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46799 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46800 }
46801 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46802 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46803 }
46804 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46805 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46806 }
46807 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46808 return (void *)((wxControl *) ((wxControlWithItems *) x));
46809 }
46810 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46811 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46812 }
46813 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46814 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46815 }
46816 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46817 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46818 }
46819 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46820 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46821 }
46822 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46823 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46824 }
46825 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46826 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46827 }
46828 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46829 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46830 }
46831 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46832 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46833 }
46834 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46835 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46836 }
46837 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46838 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46839 }
46840 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46841 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46842 }
46843 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46844 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46845 }
46846 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46847 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46848 }
46849 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46850 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46851 }
46852 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46853 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46854 }
46855 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46856 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46857 }
46858 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46859 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46860 }
46861 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46862 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46863 }
46864 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46865 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46866 }
46867 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46868 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46869 }
46870 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46871 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46872 }
46873 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46874 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46875 }
46876 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46877 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46878 }
46879 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46880 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46881 }
46882 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46883 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46884 }
46885 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46886 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46887 }
46888 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46889 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46890 }
46891 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46892 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46893 }
46894 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46895 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46896 }
46897 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46898 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46899 }
46900 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46901 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46902 }
46903 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46904 return (void *)((wxObject *) ((wxSizerItem *) x));
46905 }
46906 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46907 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46908 }
46909 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46910 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46911 }
46912 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46913 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46914 }
46915 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46916 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46917 }
46918 static void *_p_wxSizerTo_p_wxObject(void *x) {
46919 return (void *)((wxObject *) ((wxSizer *) x));
46920 }
46921 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46922 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46923 }
46924 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46925 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46926 }
46927 static void *_p_wxEventTo_p_wxObject(void *x) {
46928 return (void *)((wxObject *) ((wxEvent *) x));
46929 }
46930 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46931 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46932 }
46933 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46934 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46935 }
46936 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46937 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46938 }
46939 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46940 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46941 }
46942 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46943 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46944 }
46945 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46946 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46947 }
46948 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46949 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46950 }
46951 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46952 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46953 }
46954 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46955 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46956 }
46957 static void *_p_wxControlTo_p_wxObject(void *x) {
46958 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46959 }
46960 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46961 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46962 }
46963 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46964 return (void *)((wxObject *) ((wxFSFile *) x));
46965 }
46966 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46967 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46968 }
46969 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46970 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46971 }
46972 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46974 }
46975 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46976 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46977 }
46978 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46979 return (void *)((wxObject *) ((wxMenuItem *) x));
46980 }
46981 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46983 }
46984 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46985 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46986 }
46987 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46989 }
46990 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46991 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46992 }
46993 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46994 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46995 }
46996 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46997 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46998 }
46999 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47000 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47001 }
47002 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47003 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47004 }
47005 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47006 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47007 }
47008 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47009 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47010 }
47011 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47012 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47013 }
47014 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47015 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47016 }
47017 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47018 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47019 }
47020 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47021 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47022 }
47023 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47024 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47025 }
47026 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47027 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47028 }
47029 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47030 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47031 }
47032 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47033 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47034 }
47035 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47036 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47037 }
47038 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47039 return (void *)((wxObject *) ((wxImageHandler *) x));
47040 }
47041 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47042 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47043 }
47044 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47045 return (void *)((wxObject *) ((wxEvtHandler *) x));
47046 }
47047 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47048 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47049 }
47050 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47051 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47052 }
47053 static void *_p_wxImageTo_p_wxObject(void *x) {
47054 return (void *)((wxObject *) ((wxImage *) x));
47055 }
47056 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47057 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47058 }
47059 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47061 }
47062 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47063 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47064 }
47065 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47066 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47067 }
47068 static void *_p_wxWindowTo_p_wxObject(void *x) {
47069 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47070 }
47071 static void *_p_wxMenuTo_p_wxObject(void *x) {
47072 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47073 }
47074 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47075 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47076 }
47077 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47078 return (void *)((wxObject *) ((wxFileSystem *) x));
47079 }
47080 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47082 }
47083 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47084 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47085 }
47086 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47087 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47088 }
47089 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47090 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47091 }
47092 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47093 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47094 }
47095 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47096 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47097 }
47098 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47099 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47100 }
47101 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47102 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47103 }
47104 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47105 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47106 }
47107 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47108 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47109 }
47110 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47111 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47112 }
47113 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47114 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47115 }
47116 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47117 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47118 }
47119 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47120 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47121 }
47122 static void *_p_wxControlTo_p_wxWindow(void *x) {
47123 return (void *)((wxWindow *) ((wxControl *) x));
47124 }
47125 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47126 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47127 }
47128 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47129 return (void *)((wxWindow *) ((wxMenuBar *) x));
47130 }
47131 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47132 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47133 }
47134 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47135 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47136 }
47137 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47138 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47139 }
47140 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47141 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47142 }
47143 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47144 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47145 }
47146 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47147 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47148 }
47149 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47150 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47151 }
47152 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47153 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47154 }
47155 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47156 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47157 }
47158 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47159 return (void *)((wxValidator *) ((wxPyValidator *) x));
47160 }
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281 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}};
47282 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}};
47283 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}};
47284 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}};
47285 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}};
47286 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}};
47287 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}};
47288 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}};
47289
47290 static swig_type_info *swig_types_initial[] = {
47291 _swigt__p_wxLayoutConstraints,
47292 _swigt__p_wxRealPoint,
47293 _swigt__p_wxSizerItem,
47294 _swigt__p_wxGBSizerItem,
47295 _swigt__p_wxScrollEvent,
47296 _swigt__p_wxEventLoop,
47297 _swigt__p_wxIndividualLayoutConstraint,
47298 _swigt__p_wxSizer,
47299 _swigt__p_wxBoxSizer,
47300 _swigt__p_wxStaticBoxSizer,
47301 _swigt__p_wxGridBagSizer,
47302 _swigt__p_wxAcceleratorEntry,
47303 _swigt__p_wxUpdateUIEvent,
47304 _swigt__p_wxEvent,
47305 _swigt__p_buffer,
47306 _swigt__p_wxMenu,
47307 _swigt__p_wxGridSizer,
47308 _swigt__p_wxFlexGridSizer,
47309 _swigt__p_wxInitDialogEvent,
47310 _swigt__p_wxItemContainer,
47311 _swigt__p_wxNcPaintEvent,
47312 _swigt__p_wxPaintEvent,
47313 _swigt__p_wxSysColourChangedEvent,
47314 _swigt__p_wxMouseCaptureChangedEvent,
47315 _swigt__p_wxDisplayChangedEvent,
47316 _swigt__p_wxPaletteChangedEvent,
47317 _swigt__p_wxControl,
47318 _swigt__p_wxFont,
47319 _swigt__p_wxMenuBarBase,
47320 _swigt__p_wxSetCursorEvent,
47321 _swigt__p_wxFSFile,
47322 _swigt__p_wxCaret,
47323 _swigt__ptrdiff_t,
47324 _swigt__std__ptrdiff_t,
47325 _swigt__p_wxRegion,
47326 _swigt__p_wxPoint2D,
47327 _swigt__p_int,
47328 _swigt__p_wxSize,
47329 _swigt__p_wxDC,
47330 _swigt__p_wxPySizer,
47331 _swigt__p_wxVisualAttributes,
47332 _swigt__p_wxNotifyEvent,
47333 _swigt__p_wxPyEvent,
47334 _swigt__p_wxPropagationDisabler,
47335 _swigt__p_form_ops_t,
47336 _swigt__p_wxAppTraits,
47337 _swigt__p_wxArrayString,
47338 _swigt__p_wxShowEvent,
47339 _swigt__p_wxToolTip,
47340 _swigt__p_wxMoveEvent,
47341 _swigt__p_wxSizeEvent,
47342 _swigt__p_wxActivateEvent,
47343 _swigt__p_wxIconizeEvent,
47344 _swigt__p_wxMaximizeEvent,
47345 _swigt__p_wxQueryNewPaletteEvent,
47346 _swigt__p_wxWindowCreateEvent,
47347 _swigt__p_wxIdleEvent,
47348 _swigt__p_wxDateEvent,
47349 _swigt__p_wxMenuItem,
47350 _swigt__p_wxStaticBox,
47351 _swigt__p_long,
47352 _swigt__p_wxDuplexMode,
47353 _swigt__p_wxTIFFHandler,
47354 _swigt__p_wxXPMHandler,
47355 _swigt__p_wxPNMHandler,
47356 _swigt__p_wxJPEGHandler,
47357 _swigt__p_wxPCXHandler,
47358 _swigt__p_wxGIFHandler,
47359 _swigt__p_wxPNGHandler,
47360 _swigt__p_wxANIHandler,
47361 _swigt__p_wxMemoryFSHandler,
47362 _swigt__p_wxZipFSHandler,
47363 _swigt__p_wxInternetFSHandler,
47364 _swigt__p_wxPyFileSystemHandler,
47365 _swigt__p_wxEvtHandler,
47366 _swigt__p_wxCURHandler,
47367 _swigt__p_wxICOHandler,
47368 _swigt__p_wxBMPHandler,
47369 _swigt__p_wxImageHandler,
47370 _swigt__p_wxFileSystemHandler,
47371 _swigt__p_wxRect,
47372 _swigt__p_wxButton,
47373 _swigt__p_wxGBSpan,
47374 _swigt__p_wxPropagateOnce,
47375 _swigt__p_wxAcceleratorTable,
47376 _swigt__p_wxStdDialogButtonSizer,
47377 _swigt__p_char,
47378 _swigt__p_wxGBPosition,
47379 _swigt__p_wxImage,
47380 _swigt__p_wxFrame,
47381 _swigt__p_wxScrollWinEvent,
47382 _swigt__p_wxPaperSize,
47383 _swigt__p_wxImageHistogram,
47384 _swigt__p_wxPoint,
47385 _swigt__p_wxCursor,
47386 _swigt__p_wxObject,
47387 _swigt__p_wxInputStream,
47388 _swigt__p_wxOutputStream,
47389 _swigt__p_wxPyInputStream,
47390 _swigt__p_wxDateTime,
47391 _swigt__p_wxKeyEvent,
47392 _swigt__p_wxNavigationKeyEvent,
47393 _swigt__p_wxWindowDestroyEvent,
47394 _swigt__p_unsigned_long,
47395 _swigt__p_wxWindow,
47396 _swigt__p_wxMenuBar,
47397 _swigt__p_wxFileSystem,
47398 _swigt__p_wxBitmap,
47399 _swigt__unsigned_int,
47400 _swigt__p_unsigned_int,
47401 _swigt__p_wxMenuEvent,
47402 _swigt__p_wxContextMenuEvent,
47403 _swigt__p_unsigned_char,
47404 _swigt__p_wxEraseEvent,
47405 _swigt__p_wxMouseEvent,
47406 _swigt__p_wxCloseEvent,
47407 _swigt__p_wxPyApp,
47408 _swigt__p_wxCommandEvent,
47409 _swigt__p_wxPyCommandEvent,
47410 _swigt__p_wxPyDropTarget,
47411 _swigt__p_wxQuantize,
47412 _swigt__p_wxFocusEvent,
47413 _swigt__p_wxChildFocusEvent,
47414 _swigt__p_wxDropFilesEvent,
47415 _swigt__p_wxControlWithItems,
47416 _swigt__p_wxColour,
47417 _swigt__p_wxValidator,
47418 _swigt__p_wxPyValidator,
47419 0
47420 };
47421
47422
47423 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47424
47425 static swig_const_info swig_const_table[] = {
47426 {0, 0, 0, 0.0, 0, 0}};
47427
47428 #ifdef __cplusplus
47429 }
47430 #endif
47431
47432
47433 #ifdef __cplusplus
47434 extern "C" {
47435 #endif
47436
47437 /* Python-specific SWIG API */
47438 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47439 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47440 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47441
47442 /* -----------------------------------------------------------------------------
47443 * global variable support code.
47444 * ----------------------------------------------------------------------------- */
47445
47446 typedef struct swig_globalvar {
47447 char *name; /* Name of global variable */
47448 PyObject *(*get_attr)(); /* Return the current value */
47449 int (*set_attr)(PyObject *); /* Set the value */
47450 struct swig_globalvar *next;
47451 } swig_globalvar;
47452
47453 typedef struct swig_varlinkobject {
47454 PyObject_HEAD
47455 swig_globalvar *vars;
47456 } swig_varlinkobject;
47457
47458 static PyObject *
47459 swig_varlink_repr(swig_varlinkobject *v) {
47460 v = v;
47461 return PyString_FromString("<Swig global variables>");
47462 }
47463
47464 static int
47465 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47466 swig_globalvar *var;
47467 flags = flags;
47468 fprintf(fp,"Swig global variables { ");
47469 for (var = v->vars; var; var=var->next) {
47470 fprintf(fp,"%s", var->name);
47471 if (var->next) fprintf(fp,", ");
47472 }
47473 fprintf(fp," }\n");
47474 return 0;
47475 }
47476
47477 static PyObject *
47478 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47479 swig_globalvar *var = v->vars;
47480 while (var) {
47481 if (strcmp(var->name,n) == 0) {
47482 return (*var->get_attr)();
47483 }
47484 var = var->next;
47485 }
47486 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47487 return NULL;
47488 }
47489
47490 static int
47491 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47492 swig_globalvar *var = v->vars;
47493 while (var) {
47494 if (strcmp(var->name,n) == 0) {
47495 return (*var->set_attr)(p);
47496 }
47497 var = var->next;
47498 }
47499 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47500 return 1;
47501 }
47502
47503 static PyTypeObject varlinktype = {
47504 PyObject_HEAD_INIT(0)
47505 0, /* Number of items in variable part (ob_size) */
47506 (char *)"swigvarlink", /* Type name (tp_name) */
47507 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47508 0, /* Itemsize (tp_itemsize) */
47509 0, /* Deallocator (tp_dealloc) */
47510 (printfunc) swig_varlink_print, /* Print (tp_print) */
47511 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47512 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47513 0, /* tp_compare */
47514 (reprfunc) swig_varlink_repr, /* tp_repr */
47515 0, /* tp_as_number */
47516 0, /* tp_as_sequence */
47517 0, /* tp_as_mapping */
47518 0, /* tp_hash */
47519 0, /* tp_call */
47520 0, /* tp_str */
47521 0, /* tp_getattro */
47522 0, /* tp_setattro */
47523 0, /* tp_as_buffer */
47524 0, /* tp_flags */
47525 0, /* tp_doc */
47526 #if PY_VERSION_HEX >= 0x02000000
47527 0, /* tp_traverse */
47528 0, /* tp_clear */
47529 #endif
47530 #if PY_VERSION_HEX >= 0x02010000
47531 0, /* tp_richcompare */
47532 0, /* tp_weaklistoffset */
47533 #endif
47534 #if PY_VERSION_HEX >= 0x02020000
47535 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47536 #endif
47537 #if PY_VERSION_HEX >= 0x02030000
47538 0, /* tp_del */
47539 #endif
47540 #ifdef COUNT_ALLOCS
47541 0,0,0,0 /* tp_alloc -> tp_next */
47542 #endif
47543 };
47544
47545 /* Create a variable linking object for use later */
47546 static PyObject *
47547 SWIG_Python_newvarlink(void) {
47548 swig_varlinkobject *result = 0;
47549 result = PyMem_NEW(swig_varlinkobject,1);
47550 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47551 result->ob_type = &varlinktype;
47552 result->vars = 0;
47553 result->ob_refcnt = 0;
47554 Py_XINCREF((PyObject *) result);
47555 return ((PyObject*) result);
47556 }
47557
47558 static void
47559 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47560 swig_varlinkobject *v;
47561 swig_globalvar *gv;
47562 v= (swig_varlinkobject *) p;
47563 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47564 gv->name = (char *) malloc(strlen(name)+1);
47565 strcpy(gv->name,name);
47566 gv->get_attr = get_attr;
47567 gv->set_attr = set_attr;
47568 gv->next = v->vars;
47569 v->vars = gv;
47570 }
47571
47572 /* -----------------------------------------------------------------------------
47573 * constants/methods manipulation
47574 * ----------------------------------------------------------------------------- */
47575
47576 /* Install Constants */
47577 static void
47578 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47579 PyObject *obj = 0;
47580 size_t i;
47581 for (i = 0; constants[i].type; i++) {
47582 switch(constants[i].type) {
47583 case SWIG_PY_INT:
47584 obj = PyInt_FromLong(constants[i].lvalue);
47585 break;
47586 case SWIG_PY_FLOAT:
47587 obj = PyFloat_FromDouble(constants[i].dvalue);
47588 break;
47589 case SWIG_PY_STRING:
47590 if (constants[i].pvalue) {
47591 obj = PyString_FromString((char *) constants[i].pvalue);
47592 } else {
47593 Py_INCREF(Py_None);
47594 obj = Py_None;
47595 }
47596 break;
47597 case SWIG_PY_POINTER:
47598 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47599 break;
47600 case SWIG_PY_BINARY:
47601 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47602 break;
47603 default:
47604 obj = 0;
47605 break;
47606 }
47607 if (obj) {
47608 PyDict_SetItemString(d,constants[i].name,obj);
47609 Py_DECREF(obj);
47610 }
47611 }
47612 }
47613
47614 /* -----------------------------------------------------------------------------*/
47615 /* Fix SwigMethods to carry the callback ptrs when needed */
47616 /* -----------------------------------------------------------------------------*/
47617
47618 static void
47619 SWIG_Python_FixMethods(PyMethodDef *methods,
47620 swig_const_info *const_table,
47621 swig_type_info **types,
47622 swig_type_info **types_initial) {
47623 size_t i;
47624 for (i = 0; methods[i].ml_name; ++i) {
47625 char *c = methods[i].ml_doc;
47626 if (c && (c = strstr(c, "swig_ptr: "))) {
47627 int j;
47628 swig_const_info *ci = 0;
47629 char *name = c + 10;
47630 for (j = 0; const_table[j].type; j++) {
47631 if (strncmp(const_table[j].name, name,
47632 strlen(const_table[j].name)) == 0) {
47633 ci = &(const_table[j]);
47634 break;
47635 }
47636 }
47637 if (ci) {
47638 size_t shift = (ci->ptype) - types;
47639 swig_type_info *ty = types_initial[shift];
47640 size_t ldoc = (c - methods[i].ml_doc);
47641 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47642 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47643 char *buff = ndoc;
47644 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47645 strncpy(buff, methods[i].ml_doc, ldoc);
47646 buff += ldoc;
47647 strncpy(buff, "swig_ptr: ", 10);
47648 buff += 10;
47649 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47650 methods[i].ml_doc = ndoc;
47651 }
47652 }
47653 }
47654 }
47655
47656 /* -----------------------------------------------------------------------------*
47657 * Initialize type list
47658 * -----------------------------------------------------------------------------*/
47659
47660 #if PY_MAJOR_VERSION < 2
47661 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47662 is copied out of Python/modsupport.c in python version 2.3.4 */
47663 static int
47664 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47665 {
47666 PyObject *dict;
47667 if (!PyModule_Check(m)) {
47668 PyErr_SetString(PyExc_TypeError,
47669 "PyModule_AddObject() needs module as first arg");
47670 return -1;
47671 }
47672 if (!o) {
47673 PyErr_SetString(PyExc_TypeError,
47674 "PyModule_AddObject() needs non-NULL value");
47675 return -1;
47676 }
47677
47678 dict = PyModule_GetDict(m);
47679 if (dict == NULL) {
47680 /* Internal error -- modules must have a dict! */
47681 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47682 PyModule_GetName(m));
47683 return -1;
47684 }
47685 if (PyDict_SetItemString(dict, name, o))
47686 return -1;
47687 Py_DECREF(o);
47688 return 0;
47689 }
47690 #endif
47691
47692 static swig_type_info **
47693 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47694 static PyMethodDef swig_empty_runtime_method_table[] = {
47695 {
47696 NULL, NULL, 0, NULL
47697 }
47698 };/* Sentinel */
47699
47700 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47701 swig_empty_runtime_method_table);
47702 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47703 if (pointer && module) {
47704 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47705 }
47706 return type_list_handle;
47707 }
47708
47709 static swig_type_info **
47710 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47711 swig_type_info **type_pointer;
47712
47713 /* first check if module already created */
47714 type_pointer = SWIG_Python_GetTypeListHandle();
47715 if (type_pointer) {
47716 return type_pointer;
47717 } else {
47718 /* create a new module and variable */
47719 return SWIG_Python_SetTypeListHandle(type_list_handle);
47720 }
47721 }
47722
47723 #ifdef __cplusplus
47724 }
47725 #endif
47726
47727 /* -----------------------------------------------------------------------------*
47728 * Partial Init method
47729 * -----------------------------------------------------------------------------*/
47730
47731 #ifdef SWIG_LINK_RUNTIME
47732 #ifdef __cplusplus
47733 extern "C"
47734 #endif
47735 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47736 #endif
47737
47738 #ifdef __cplusplus
47739 extern "C"
47740 #endif
47741 SWIGEXPORT(void) SWIG_init(void) {
47742 static PyObject *SWIG_globals = 0;
47743 static int typeinit = 0;
47744 PyObject *m, *d;
47745 int i;
47746 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47747
47748 /* Fix SwigMethods to carry the callback ptrs when needed */
47749 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47750
47751 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47752 d = PyModule_GetDict(m);
47753
47754 if (!typeinit) {
47755 #ifdef SWIG_LINK_RUNTIME
47756 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47757 #else
47758 # ifndef SWIG_STATIC_RUNTIME
47759 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47760 # endif
47761 #endif
47762 for (i = 0; swig_types_initial[i]; i++) {
47763 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47764 }
47765 typeinit = 1;
47766 }
47767 SWIG_InstallConstants(d,swig_const_table);
47768
47769
47770 #ifndef wxPyUSE_EXPORT
47771 // Make our API structure a CObject so other modules can import it
47772 // from this module.
47773 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47774 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47775 Py_XDECREF(cobj);
47776 #endif
47777
47778 {
47779 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49436 }
49437 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49438 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49439 {
49440 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49591 }
49592 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49593 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49594 {
49595 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49602 }
49603
49604 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49605
49606
49607 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49608
49609 {
49610 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49617 }
49618 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49619 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49620 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49621 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49622 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49623 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49624 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49625 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49626 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49627 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49628 {
49629 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49633 }
49634 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49635 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49636 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49637 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49638 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49639 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49640 {
49641 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49687 }
49688 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49689 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49690 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49691 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49692 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49693 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49694 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49695 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49696 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49697 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49698 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49699 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49700 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49701 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49702 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49703 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49704 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49705 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49706 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49707 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49708 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49709 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49710 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49711 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49712 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49713 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49714 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49715 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49716 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49717 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49718 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49719 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49720 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49721 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49722 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49723 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49724 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49725 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49726 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49727 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49728 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49729 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49730 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49731 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49732 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49733 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49734 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49735 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49736 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49737 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49738 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49739 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49740 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49741 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49742 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49743 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49744 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49745 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49746 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49747 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49748 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49749 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49750 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49751 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49752 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49753 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49754 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49755 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49756 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49757 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49758 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49759 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49760 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49761 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49762 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49763 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49764 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49765 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49766 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49767 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49768 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49769 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49770 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49771 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49772 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49773 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49774 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49775 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49776 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49777 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49778 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49779 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49780 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49781 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49782 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49783 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49784 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49785 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49786 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49787 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49788 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49789 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49790 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49791 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49792 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49793 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49794 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49795 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49796 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49797 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49798 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49799 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49800 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49801 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49802 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49803 {
49804 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49841 }
49842 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49843 {
49844 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49860 }
49861 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49862 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49863 {
49864 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49871 }
49872 {
49873 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49877 }
49878 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49879 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49880 {
49881 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49888 }
49889 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49890 {
49891 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49946 }
49947
49948 // Initialize threading, some globals and such
49949 __wxPyPreStart(d);
49950
49951
49952 // Although these are defined in __version__ they need to be here too so
49953 // that an assert can be done to ensure that the wxPython and the wxWindows
49954 // versions match.
49955 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49956 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49957 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49958
49959 }
49960
wxWidgets (Impactor)