projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added support for current version of "emxomf".
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 #if !WXWIN_COMPATIBILITY_2_4
1663 #define wxHIDE_READONLY 0
1664 #endif
1665
1666
1667 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1668 #define SWIG_From_int PyInt_FromLong
1669 /*@@*/
1670
1671
1672 #if ! wxUSE_HOTKEY
1673 enum wxHotkeyModifier
1674 {
1675 wxMOD_NONE = 0,
1676 wxMOD_ALT = 1,
1677 wxMOD_CONTROL = 2,
1678 wxMOD_SHIFT = 4,
1679 wxMOD_WIN = 8
1680 };
1681 #define wxEVT_HOTKEY 9999
1682 #endif
1683
1684 static const wxString wxPyEmptyString(wxEmptyString);
1685 static wxString wxObject_GetClassName(wxObject *self){
1686 return self->GetClassInfo()->GetClassName();
1687 }
1688 static void wxObject_Destroy(wxObject *self){
1689 delete self;
1690 }
1691
1692 #ifndef __WXMAC__
1693 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1694 #endif
1695
1696
1697 #include <limits.h>
1698
1699
1700 SWIGINTERN int
1701 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1702 const char *errmsg)
1703 {
1704 if (value < min_value) {
1705 if (errmsg) {
1706 PyErr_Format(PyExc_OverflowError,
1707 "value %ld is less than '%s' minimum %ld",
1708 value, errmsg, min_value);
1709 }
1710 return 0;
1711 } else if (value > max_value) {
1712 if (errmsg) {
1713 PyErr_Format(PyExc_OverflowError,
1714 "value %ld is greater than '%s' maximum %ld",
1715 value, errmsg, max_value);
1716 }
1717 return 0;
1718 }
1719 return 1;
1720 }
1721
1722
1723 SWIGINTERN int
1724 SWIG_AsVal_long(PyObject* obj, long* val)
1725 {
1726 if (PyNumber_Check(obj)) {
1727 if (val) *val = PyInt_AsLong(obj);
1728 return 1;
1729 }
1730 else {
1731 SWIG_type_error("number", obj);
1732 }
1733 return 0;
1734 }
1735
1736
1737 #if INT_MAX != LONG_MAX
1738 SWIGINTERN int
1739 SWIG_AsVal_int(PyObject *obj, int *val)
1740 {
1741 const char* errmsg = val ? "int" : (char*)0;
1742 long v;
1743 if (SWIG_AsVal_long(obj, &v)) {
1744 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1745 if (val) *val = (int)(v);
1746 return 1;
1747 } else {
1748 return 0;
1749 }
1750 } else {
1751 PyErr_Clear();
1752 }
1753 if (val) {
1754 SWIG_type_error(errmsg, obj);
1755 }
1756 return 0;
1757 }
1758 #else
1759 SWIGINTERNSHORT int
1760 SWIG_AsVal_int(PyObject *obj, int *val)
1761 {
1762 return SWIG_AsVal_long(obj,(long*)val);
1763 }
1764 #endif
1765
1766
1767 SWIGINTERNSHORT int
1768 SWIG_As_int(PyObject* obj)
1769 {
1770 int v;
1771 if (!SWIG_AsVal_int(obj, &v)) {
1772 /*
1773 this is needed to make valgrind/purify happier.
1774 */
1775 memset((void*)&v, 0, sizeof(int));
1776 }
1777 return v;
1778 }
1779
1780
1781 SWIGINTERNSHORT int
1782 SWIG_Check_int(PyObject* obj)
1783 {
1784 return SWIG_AsVal_int(obj, (int*)0);
1785 }
1786
1787 static PyObject *wxSize_Get(wxSize *self){
1788 bool blocked = wxPyBeginBlockThreads();
1789 PyObject* tup = PyTuple_New(2);
1790 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1791 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1792 wxPyEndBlockThreads(blocked);
1793 return tup;
1794 }
1795
1796 SWIGINTERN int
1797 SWIG_AsVal_double(PyObject *obj, double* val)
1798 {
1799 if (PyNumber_Check(obj)) {
1800 if (val) *val = PyFloat_AsDouble(obj);
1801 return 1;
1802 }
1803 else {
1804 SWIG_type_error("number", obj);
1805 }
1806 return 0;
1807 }
1808
1809
1810 SWIGINTERNSHORT double
1811 SWIG_As_double(PyObject* obj)
1812 {
1813 double v;
1814 if (!SWIG_AsVal_double(obj, &v)) {
1815 /*
1816 this is needed to make valgrind/purify happier.
1817 */
1818 memset((void*)&v, 0, sizeof(double));
1819 }
1820 return v;
1821 }
1822
1823
1824 SWIGINTERNSHORT int
1825 SWIG_Check_double(PyObject* obj)
1826 {
1827 return SWIG_AsVal_double(obj, (double*)0);
1828 }
1829
1830
1831 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1832 #define SWIG_From_double PyFloat_FromDouble
1833 /*@@*/
1834
1835 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1836 self->x = x;
1837 self->y = y;
1838 }
1839 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1840 bool blocked = wxPyBeginBlockThreads();
1841 PyObject* tup = PyTuple_New(2);
1842 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1843 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1844 wxPyEndBlockThreads(blocked);
1845 return tup;
1846 }
1847
1848 SWIGINTERNSHORT long
1849 SWIG_As_long(PyObject* obj)
1850 {
1851 long v;
1852 if (!SWIG_AsVal_long(obj, &v)) {
1853 /*
1854 this is needed to make valgrind/purify happier.
1855 */
1856 memset((void*)&v, 0, sizeof(long));
1857 }
1858 return v;
1859 }
1860
1861
1862 SWIGINTERNSHORT int
1863 SWIG_Check_long(PyObject* obj)
1864 {
1865 return SWIG_AsVal_long(obj, (long*)0);
1866 }
1867
1868 static void wxPoint_Set(wxPoint *self,long x,long y){
1869 self->x = x;
1870 self->y = y;
1871 }
1872 static PyObject *wxPoint_Get(wxPoint *self){
1873 bool blocked = wxPyBeginBlockThreads();
1874 PyObject* tup = PyTuple_New(2);
1875 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1876 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1877 wxPyEndBlockThreads(blocked);
1878 return tup;
1879 }
1880 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1881 self->x = x;
1882 self->y = y;
1883 self->width = width;
1884 self->height = height;
1885 }
1886 static PyObject *wxRect_Get(wxRect *self){
1887 bool blocked = wxPyBeginBlockThreads();
1888 PyObject* tup = PyTuple_New(4);
1889 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1890 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1891 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1892 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1893 wxPyEndBlockThreads(blocked);
1894 return tup;
1895 }
1896
1897 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1898 wxRegion reg1(*r1);
1899 wxRegion reg2(*r2);
1900 wxRect dest(0,0,0,0);
1901 PyObject* obj;
1902
1903 reg1.Intersect(reg2);
1904 dest = reg1.GetBox();
1905
1906 if (dest != wxRect(0,0,0,0)) {
1907 bool blocked = wxPyBeginBlockThreads();
1908 wxRect* newRect = new wxRect(dest);
1909 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1910 wxPyEndBlockThreads(blocked);
1911 return obj;
1912 }
1913 Py_INCREF(Py_None);
1914 return Py_None;
1915 }
1916
1917
1918 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1919 PyObject* o2;
1920 PyObject* o3;
1921
1922 if (!target) {
1923 target = o;
1924 } else if (target == Py_None) {
1925 Py_DECREF(Py_None);
1926 target = o;
1927 } else {
1928 if (!PyTuple_Check(target)) {
1929 o2 = target;
1930 target = PyTuple_New(1);
1931 PyTuple_SetItem(target, 0, o2);
1932 }
1933 o3 = PyTuple_New(1);
1934 PyTuple_SetItem(o3, 0, o);
1935
1936 o2 = target;
1937 target = PySequence_Concat(o2, o3);
1938 Py_DECREF(o2);
1939 Py_DECREF(o3);
1940 }
1941 return target;
1942 }
1943
1944
1945 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1946 self->m_x = x;
1947 self->m_y = y;
1948 }
1949 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1950 bool blocked = wxPyBeginBlockThreads();
1951 PyObject* tup = PyTuple_New(2);
1952 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1953 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1954 wxPyEndBlockThreads(blocked);
1955 return tup;
1956 }
1957
1958 #include "wx/wxPython/pyistream.h"
1959
1960 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1961 wxInputStream* wxis = wxPyCBInputStream::create(p);
1962 if (wxis)
1963 return new wxPyInputStream(wxis);
1964 else
1965 return NULL;
1966 }
1967
1968 SWIGINTERNSHORT PyObject*
1969 SWIG_From_char(char c)
1970 {
1971 return PyString_FromStringAndSize(&c,1);
1972 }
1973
1974
1975 SWIGINTERNSHORT PyObject*
1976 SWIG_From_unsigned_SS_long(unsigned long value)
1977 {
1978 return (value > LONG_MAX) ?
1979 PyLong_FromUnsignedLong(value)
1980 : PyInt_FromLong((long)(value));
1981 }
1982
1983
1984 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1985 SWIGINTERN int
1986 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1987 {
1988 static swig_type_info* pchar_info = 0;
1989 char* vptr = 0;
1990 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1991 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1992 if (cptr) *cptr = vptr;
1993 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1994 return SWIG_OLDOBJ;
1995 } else {
1996 PyErr_Clear();
1997 if (PyString_Check(obj)) {
1998 if (cptr) {
1999 *cptr = PyString_AS_STRING(obj);
2000 if (psize) {
2001 *psize = PyString_GET_SIZE(obj) + 1;
2002 }
2003 }
2004 return SWIG_PYSTR;
2005 }
2006 }
2007 if (cptr) {
2008 SWIG_type_error("char *", obj);
2009 }
2010 return 0;
2011 }
2012
2013
2014 SWIGINTERN int
2015 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2016 {
2017 char* cptr; size_t csize;
2018 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2019 /* in C you can do:
2020
2021 char x[5] = "hello";
2022
2023 ie, assing the array using an extra '0' char.
2024 */
2025 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2026 if (csize <= size) {
2027 if (val) {
2028 if (csize) memcpy(val, cptr, csize);
2029 if (csize < size) memset(val + csize, 0, size - csize);
2030 }
2031 return 1;
2032 }
2033 }
2034 if (val) {
2035 PyErr_Format(PyExc_TypeError,
2036 "a char array of maximum size %lu is expected",
2037 (unsigned long) size);
2038 }
2039 return 0;
2040 }
2041
2042
2043 SWIGINTERN int
2044 SWIG_AsVal_char(PyObject *obj, char *val)
2045 {
2046 const char* errmsg = val ? "char" : (char*)0;
2047 long v;
2048 if (SWIG_AsVal_long(obj, &v)) {
2049 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2050 if (val) *val = (char)(v);
2051 return 1;
2052 } else {
2053 return 0;
2054 }
2055 } else {
2056 PyErr_Clear();
2057 return SWIG_AsCharArray(obj, val, 1);
2058 }
2059 }
2060
2061
2062 SWIGINTERNSHORT char
2063 SWIG_As_char(PyObject* obj)
2064 {
2065 char v;
2066 if (!SWIG_AsVal_char(obj, &v)) {
2067 /*
2068 this is needed to make valgrind/purify happier.
2069 */
2070 memset((void*)&v, 0, sizeof(char));
2071 }
2072 return v;
2073 }
2074
2075
2076 SWIGINTERNSHORT int
2077 SWIG_Check_char(PyObject* obj)
2078 {
2079 return SWIG_AsVal_char(obj, (char*)0);
2080 }
2081
2082
2083 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2084 #define SWIG_From_long PyInt_FromLong
2085 /*@@*/
2086
2087 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2088 // We use only strings for the streams, not unicode
2089 PyObject* str = PyObject_Str(obj);
2090 if (! str) {
2091 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2092 return;
2093 }
2094 self->Write(PyString_AS_STRING(str),
2095 PyString_GET_SIZE(str));
2096 Py_DECREF(str);
2097 }
2098
2099 #include "wx/wxPython/pyistream.h"
2100
2101
2102 class wxPyFileSystemHandler : public wxFileSystemHandler
2103 {
2104 public:
2105 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2106
2107 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2108 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2109 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2110 DEC_PYCALLBACK_STRING__pure(FindNext);
2111
2112 wxString GetProtocol(const wxString& location) {
2113 return wxFileSystemHandler::GetProtocol(location);
2114 }
2115
2116 wxString GetLeftLocation(const wxString& location) {
2117 return wxFileSystemHandler::GetLeftLocation(location);
2118 }
2119
2120 wxString GetAnchor(const wxString& location) {
2121 return wxFileSystemHandler::GetAnchor(location);
2122 }
2123
2124 wxString GetRightLocation(const wxString& location) {
2125 return wxFileSystemHandler::GetRightLocation(location);
2126 }
2127
2128 wxString GetMimeTypeFromExt(const wxString& location) {
2129 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2130 }
2131
2132 PYPRIVATE;
2133 };
2134
2135
2136 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2137 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2138 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2139 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2140
2141
2142 SWIGINTERN int
2143 SWIG_AsVal_bool(PyObject *obj, bool *val)
2144 {
2145 if (obj == Py_True) {
2146 if (val) *val = true;
2147 return 1;
2148 }
2149 if (obj == Py_False) {
2150 if (val) *val = false;
2151 return 1;
2152 }
2153 int res = 0;
2154 if (SWIG_AsVal_int(obj, &res)) {
2155 if (val) *val = res ? true : false;
2156 return 1;
2157 } else {
2158 PyErr_Clear();
2159 }
2160 if (val) {
2161 SWIG_type_error("bool", obj);
2162 }
2163 return 0;
2164 }
2165
2166
2167 SWIGINTERNSHORT bool
2168 SWIG_As_bool(PyObject* obj)
2169 {
2170 bool v;
2171 if (!SWIG_AsVal_bool(obj, &v)) {
2172 /*
2173 this is needed to make valgrind/purify happier.
2174 */
2175 memset((void*)&v, 0, sizeof(bool));
2176 }
2177 return v;
2178 }
2179
2180
2181 SWIGINTERNSHORT int
2182 SWIG_Check_bool(PyObject* obj)
2183 {
2184 return SWIG_AsVal_bool(obj, (bool*)0);
2185 }
2186
2187 static wxString FileSystem_URLToFileName(wxString const &url){
2188 wxFileName fname = wxFileSystem::URLToFileName(url);
2189 return fname.GetFullPath();
2190 }
2191
2192 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2193 wxImage& image,
2194 long type) {
2195 wxMemoryFSHandler::AddFile(filename, image, type);
2196 }
2197
2198 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2199 const wxBitmap& bitmap,
2200 long type) {
2201 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2202 }
2203
2204 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2205 PyObject* data) {
2206 if (! PyString_Check(data)) {
2207 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2208 "Expected string object"));
2209 return;
2210 }
2211
2212 bool blocked = wxPyBeginBlockThreads();
2213 void* ptr = (void*)PyString_AsString(data);
2214 size_t size = PyString_Size(data);
2215 wxPyEndBlockThreads(blocked);
2216
2217 wxMemoryFSHandler::AddFile(filename, ptr, size);
2218 }
2219
2220
2221 #include "wx/wxPython/pyistream.h"
2222
2223
2224 SWIGINTERN int
2225 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2226 {
2227 long v = 0;
2228 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2229 SWIG_type_error("unsigned number", obj);
2230 }
2231 else if (val)
2232 *val = (unsigned long)v;
2233 return 1;
2234 }
2235
2236
2237 SWIGINTERNSHORT int
2238 SWIG_CheckUnsignedLongInRange(unsigned long value,
2239 unsigned long max_value,
2240 const char *errmsg)
2241 {
2242 if (value > max_value) {
2243 if (errmsg) {
2244 PyErr_Format(PyExc_OverflowError,
2245 "value %lu is greater than '%s' minimum %lu",
2246 value, errmsg, max_value);
2247 }
2248 return 0;
2249 }
2250 return 1;
2251 }
2252
2253
2254 SWIGINTERN int
2255 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2256 {
2257 const char* errmsg = val ? "unsigned char" : (char*)0;
2258 unsigned long v;
2259 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2260 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2261 if (val) *val = (unsigned char)(v);
2262 return 1;
2263 } else {
2264 return 0;
2265 }
2266 } else {
2267 PyErr_Clear();
2268 }
2269 if (val) {
2270 SWIG_type_error(errmsg, obj);
2271 }
2272 return 0;
2273 }
2274
2275
2276 SWIGINTERNSHORT unsigned char
2277 SWIG_As_unsigned_SS_char(PyObject* obj)
2278 {
2279 unsigned char v;
2280 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2281 /*
2282 this is needed to make valgrind/purify happier.
2283 */
2284 memset((void*)&v, 0, sizeof(unsigned char));
2285 }
2286 return v;
2287 }
2288
2289
2290 SWIGINTERNSHORT int
2291 SWIG_Check_unsigned_SS_char(PyObject* obj)
2292 {
2293 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2294 }
2295
2296
2297 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2298 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2299 /*@@*/
2300
2301
2302 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2303 if (width > 0 && height > 0)
2304 return new wxImage(width, height, clear);
2305 else
2306 return new wxImage;
2307 }
2308 static wxImage *new_wxImage(wxBitmap const &bitmap){
2309 return new wxImage(bitmap.ConvertToImage());
2310 }
2311 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2312 // Copy the source data so the wxImage can clean it up later
2313 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2314 if (copy == NULL) {
2315 PyErr_NoMemory();
2316 return NULL;
2317 }
2318 memcpy(copy, data, width*height*3);
2319 return new wxImage(width, height, copy, false);
2320 }
2321 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2322 // Copy the source data so the wxImage can clean it up later
2323 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2324 if (dcopy == NULL) {
2325 PyErr_NoMemory();
2326 return NULL;
2327 }
2328 memcpy(dcopy, data, width*height*3);
2329 unsigned char* acopy = (unsigned char*)malloc(width*height);
2330 if (acopy == NULL) {
2331 PyErr_NoMemory();
2332 return NULL;
2333 }
2334 memcpy(acopy, alpha, width*height);
2335
2336 return new wxImage(width, height, dcopy, acopy, false);
2337 }
2338 static wxSize wxImage_GetSize(wxImage *self){
2339 wxSize size(self->GetWidth(), self->GetHeight());
2340 return size;
2341 }
2342 static PyObject *wxImage_GetData(wxImage *self){
2343 unsigned char* data = self->GetData();
2344 int len = self->GetWidth() * self->GetHeight() * 3;
2345 PyObject* rv;
2346 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2347 return rv;
2348 }
2349 static void wxImage_SetData(wxImage *self,PyObject *data){
2350 unsigned char* dataPtr;
2351
2352 if (! PyString_Check(data)) {
2353 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2354 "Expected string object"));
2355 return /* NULL */ ;
2356 }
2357
2358 size_t len = self->GetWidth() * self->GetHeight() * 3;
2359 dataPtr = (unsigned char*) malloc(len);
2360 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2361 self->SetData(dataPtr);
2362 // wxImage takes ownership of dataPtr...
2363 }
2364 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2365 unsigned char* data = self->GetData();
2366 int len = self->GetWidth() * self->GetHeight() * 3;
2367 PyObject* rv;
2368 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2369 return rv;
2370 }
2371 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2372 unsigned char* buffer;
2373 int size;
2374
2375 bool blocked = wxPyBeginBlockThreads();
2376 if (!PyArg_Parse(data, "t#", &buffer, &size))
2377 goto done;
2378
2379 if (size != self->GetWidth() * self->GetHeight() * 3) {
2380 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2381 goto done;
2382 }
2383 self->SetData(buffer);
2384 done:
2385 wxPyEndBlockThreads(blocked);
2386 }
2387 static PyObject *wxImage_GetAlphaData(wxImage *self){
2388 unsigned char* data = self->GetAlpha();
2389 if (! data) {
2390 RETURN_NONE();
2391 } else {
2392 int len = self->GetWidth() * self->GetHeight();
2393 PyObject* rv;
2394 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2395 return rv;
2396 }
2397 }
2398 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2399 unsigned char* dataPtr;
2400
2401 if (! PyString_Check(data)) {
2402 PyErr_SetString(PyExc_TypeError, "Expected string object");
2403 return /* NULL */ ;
2404 }
2405
2406 size_t len = self->GetWidth() * self->GetHeight();
2407 dataPtr = (unsigned char*) malloc(len);
2408 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2409 self->SetAlpha(dataPtr);
2410 // wxImage takes ownership of dataPtr...
2411 }
2412 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2413 unsigned char* data = self->GetAlpha();
2414 int len = self->GetWidth() * self->GetHeight();
2415 PyObject* rv;
2416 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2417 return rv;
2418 }
2419 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2420 unsigned char* buffer;
2421 int size;
2422
2423 bool blocked = wxPyBeginBlockThreads();
2424 if (!PyArg_Parse(data, "t#", &buffer, &size))
2425 goto done;
2426
2427 if (size != self->GetWidth() * self->GetHeight()) {
2428 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2429 goto done;
2430 }
2431 self->SetAlpha(buffer);
2432 done:
2433 wxPyEndBlockThreads(blocked);
2434 }
2435
2436 SWIGINTERNSHORT unsigned long
2437 SWIG_As_unsigned_SS_long(PyObject* obj)
2438 {
2439 unsigned long v;
2440 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2441 /*
2442 this is needed to make valgrind/purify happier.
2443 */
2444 memset((void*)&v, 0, sizeof(unsigned long));
2445 }
2446 return v;
2447 }
2448
2449
2450 SWIGINTERNSHORT int
2451 SWIG_Check_unsigned_SS_long(PyObject* obj)
2452 {
2453 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2454 }
2455
2456 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2457 wxBitmap bitmap(*self, depth);
2458 return bitmap;
2459 }
2460 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2461 wxImage mono = self->ConvertToMono( red, green, blue );
2462 wxBitmap bitmap( mono, 1 );
2463 return bitmap;
2464 }
2465 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2466 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2467 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2468 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2469 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2470
2471 #include <wx/quantize.h>
2472
2473 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2474 return wxQuantize::Quantize(src, dest,
2475 //NULL, // palette
2476 desiredNoColours,
2477 NULL, // eightBitData
2478 flags);
2479 }
2480 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2481 if (PyCallable_Check(func)) {
2482 self->Connect(id, lastId, eventType,
2483 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2484 new wxPyCallback(func));
2485 }
2486 else if (func == Py_None) {
2487 self->Disconnect(id, lastId, eventType,
2488 (wxObjectEventFunction)
2489 &wxPyCallback::EventThunker);
2490 }
2491 else {
2492 wxPyBLOCK_THREADS(
2493 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2494 }
2495 }
2496 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2497 return self->Disconnect(id, lastId, eventType,
2498 (wxObjectEventFunction)
2499 &wxPyCallback::EventThunker);
2500 }
2501 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2502 if (_self && _self != Py_None) {
2503 self->SetClientObject(new wxPyOORClientData(_self, incref));
2504 }
2505 else {
2506 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2507 if (data) {
2508 self->SetClientObject(NULL); // This will delete it too
2509 }
2510 }
2511 }
2512
2513 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2514 #if wxUSE_UNICODE
2515 return self->GetUnicodeKey();
2516 #else
2517 return 0;
2518 #endif
2519 }
2520
2521 #if UINT_MAX < LONG_MAX
2522 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2523 #define SWIG_From_unsigned_SS_int SWIG_From_long
2524 /*@@*/
2525 #else
2526 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2527 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2528 /*@@*/
2529 #endif
2530
2531
2532 #if UINT_MAX != ULONG_MAX
2533 SWIGINTERN int
2534 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2535 {
2536 const char* errmsg = val ? "unsigned int" : (char*)0;
2537 unsigned long v;
2538 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2539 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2540 if (val) *val = (unsigned int)(v);
2541 return 1;
2542 }
2543 } else {
2544 PyErr_Clear();
2545 }
2546 if (val) {
2547 SWIG_type_error(errmsg, obj);
2548 }
2549 return 0;
2550 }
2551 #else
2552 SWIGINTERNSHORT unsigned int
2553 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2554 {
2555 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2556 }
2557 #endif
2558
2559
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_As_unsigned_SS_int(PyObject* obj)
2562 {
2563 unsigned int v;
2564 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2565 /*
2566 this is needed to make valgrind/purify happier.
2567 */
2568 memset((void*)&v, 0, sizeof(unsigned int));
2569 }
2570 return v;
2571 }
2572
2573
2574 SWIGINTERNSHORT int
2575 SWIG_Check_unsigned_SS_int(PyObject* obj)
2576 {
2577 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2578 }
2579
2580 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2581 self->m_size = size;
2582 }
2583 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2584 int count = self->GetNumberOfFiles();
2585 wxString* files = self->GetFiles();
2586 PyObject* list = PyList_New(count);
2587
2588 if (!list) {
2589 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2590 return NULL;
2591 }
2592
2593 for (int i=0; i<count; i++) {
2594 PyList_SetItem(list, i, wx2PyString(files[i]));
2595 }
2596 return list;
2597 }
2598
2599
2600 static wxPyApp *new_wxPyApp(){
2601 wxPythonApp = new wxPyApp();
2602 return wxPythonApp;
2603 }
2604 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2605
2606 void wxApp_CleanUp() {
2607 __wxPyCleanup();
2608 }
2609
2610
2611 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2612
2613
2614 SWIGINTERNSHORT int
2615 SWIG_AsCharPtr(PyObject *obj, char **val)
2616 {
2617 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2618 return 1;
2619 }
2620 if (val) {
2621 PyErr_Clear();
2622 SWIG_type_error("char *", obj);
2623 }
2624 return 0;
2625 }
2626
2627
2628 SWIGINTERN PyObject *
2629 SWIG_FromCharPtr(const char* cptr)
2630 {
2631 if (cptr) {
2632 size_t size = strlen(cptr);
2633 if (size > INT_MAX) {
2634 return SWIG_NewPointerObj((char*)(cptr),
2635 SWIG_TypeQuery("char *"), 0);
2636 } else {
2637 if (size != 0) {
2638 return PyString_FromStringAndSize(cptr, size);
2639 } else {
2640 return PyString_FromString(cptr);
2641 }
2642 }
2643 }
2644 Py_INCREF(Py_None);
2645 return Py_None;
2646 }
2647
2648
2649 #ifdef __WXMAC__
2650
2651 // A dummy class that raises an exception if used...
2652 class wxEventLoop
2653 {
2654 public:
2655 wxEventLoop() { wxPyRaiseNotImplemented(); }
2656 int Run() { return 0; }
2657 void Exit(int rc = 0) {}
2658 bool Pending() const { return false; }
2659 bool Dispatch() { return false; }
2660 bool IsRunning() const { return false; }
2661 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2662 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2663 };
2664
2665 #else
2666
2667 #include <wx/evtloop.h>
2668
2669 #endif
2670
2671
2672
2673 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2674 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2675 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2676 static PyObject *wxWindow_GetChildren(wxWindow *self){
2677 wxWindowList& list = self->GetChildren();
2678 return wxPy_ConvertList(&list);
2679 }
2680 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2681 #if wxUSE_HOTKEY
2682 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2683 #else
2684 return false;
2685 #endif
2686 }
2687 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2688
2689
2690
2691 return false;
2692
2693 }
2694 static long wxWindow_GetHandle(wxWindow *self){
2695 return wxPyGetWinHandle(self);
2696 }
2697 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2698 self->AssociateHandle((WXWidget)handle);
2699 }
2700
2701 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2702 return wxWindow::FindWindowById(id, parent);
2703 }
2704
2705 wxWindow* wxFindWindowByName( const wxString& name,
2706 const wxWindow *parent = NULL ) {
2707 return wxWindow::FindWindowByName(name, parent);
2708 }
2709
2710 wxWindow* wxFindWindowByLabel( const wxString& label,
2711 const wxWindow *parent = NULL ) {
2712 return wxWindow::FindWindowByLabel(label, parent);
2713 }
2714
2715
2716 #ifdef __WXMSW__
2717 #include <wx/msw/private.h> // to get wxGetWindowId
2718 #endif
2719
2720
2721 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2722 #ifdef __WXMSW__
2723 WXHWND hWnd = (WXHWND)_hWnd;
2724 long id = wxGetWindowId(hWnd);
2725 wxWindow* win = new wxWindow;
2726 parent->AddChild(win);
2727 win->SetEventHandler(win);
2728 win->SetHWND(hWnd);
2729 win->SetId(id);
2730 win->SubclassWin(hWnd);
2731 win->AdoptAttributesFromHWND();
2732 win->SetupColours();
2733 return win;
2734 #else
2735 wxPyRaiseNotImplemented();
2736 return NULL;
2737 #endif
2738 }
2739
2740
2741 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2742 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2743 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2744
2745 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2746
2747 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2748 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2749 wxMenuItemList& list = self->GetMenuItems();
2750 return wxPy_ConvertList(&list);
2751 }
2752 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2753 static const wxString wxPyControlNameStr(wxControlNameStr);
2754 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2755 if (clientData) {
2756 wxPyClientData* data = new wxPyClientData(clientData);
2757 return self->Append(item, data);
2758 } else
2759 return self->Append(item);
2760 }
2761 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2762 if (clientData) {
2763 wxPyClientData* data = new wxPyClientData(clientData);
2764 return self->Insert(item, pos, data);
2765 } else
2766 return self->Insert(item, pos);
2767 }
2768 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2769 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2770 if (data) {
2771 Py_INCREF(data->m_obj);
2772 return data->m_obj;
2773 } else {
2774 Py_INCREF(Py_None);
2775 return Py_None;
2776 }
2777 }
2778 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2779 wxPyClientData* data = new wxPyClientData(clientData);
2780 self->SetClientObject(n, data);
2781 }
2782
2783
2784 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2785 wxPyUserData* data = NULL;
2786 if ( userData ) {
2787 bool blocked = wxPyBeginBlockThreads();
2788 data = new wxPyUserData(userData);
2789 wxPyEndBlockThreads(blocked);
2790 }
2791 return new wxSizerItem(window, proportion, flag, border, data);
2792 }
2793 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2794 wxPyUserData* data = NULL;
2795 if ( userData ) {
2796 bool blocked = wxPyBeginBlockThreads();
2797 data = new wxPyUserData(userData);
2798 wxPyEndBlockThreads(blocked);
2799 }
2800 return new wxSizerItem(width, height, proportion, flag, border, data);
2801 }
2802 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2803 wxPyUserData* data = NULL;
2804 if ( userData ) {
2805 bool blocked = wxPyBeginBlockThreads();
2806 data = new wxPyUserData(userData);
2807 wxPyEndBlockThreads(blocked);
2808 }
2809 return new wxSizerItem(sizer, proportion, flag, border, data);
2810 }
2811
2812 #include <float.h>
2813 SWIGINTERN int
2814 SWIG_CheckDoubleInRange(double value, double min_value,
2815 double max_value, const char* errmsg)
2816 {
2817 if (value < min_value) {
2818 if (errmsg) {
2819 PyErr_Format(PyExc_OverflowError,
2820 "value %g is less than %s minimum %g",
2821 value, errmsg, min_value);
2822 }
2823 return 0;
2824 } else if (value > max_value) {
2825 if (errmsg) {
2826 PyErr_Format(PyExc_OverflowError,
2827 "value %g is greater than %s maximum %g",
2828 value, errmsg, max_value);
2829 }
2830 return 0;
2831 }
2832 return 1;
2833 }
2834
2835
2836 SWIGINTERN int
2837 SWIG_AsVal_float(PyObject *obj, float *val)
2838 {
2839 const char* errmsg = val ? "float" : (char*)0;
2840 double v;
2841 if (SWIG_AsVal_double(obj, &v)) {
2842 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2843 if (val) *val = (float)(v);
2844 return 1;
2845 } else {
2846 return 0;
2847 }
2848 } else {
2849 PyErr_Clear();
2850 }
2851 if (val) {
2852 SWIG_type_error(errmsg, obj);
2853 }
2854 return 0;
2855 }
2856
2857
2858 SWIGINTERNSHORT float
2859 SWIG_As_float(PyObject* obj)
2860 {
2861 float v;
2862 if (!SWIG_AsVal_float(obj, &v)) {
2863 /*
2864 this is needed to make valgrind/purify happier.
2865 */
2866 memset((void*)&v, 0, sizeof(float));
2867 }
2868 return v;
2869 }
2870
2871
2872 SWIGINTERNSHORT int
2873 SWIG_Check_float(PyObject* obj)
2874 {
2875 return SWIG_AsVal_float(obj, (float*)0);
2876 }
2877
2878
2879 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2880 #define SWIG_From_float PyFloat_FromDouble
2881 /*@@*/
2882
2883 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2884 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2885 if (data) {
2886 Py_INCREF(data->m_obj);
2887 return data->m_obj;
2888 } else {
2889 Py_INCREF(Py_None);
2890 return Py_None;
2891 }
2892 }
2893
2894 // Figure out the type of the sizer item
2895
2896 struct wxPySizerItemInfo {
2897 wxPySizerItemInfo()
2898 : window(NULL), sizer(NULL), gotSize(false),
2899 size(wxDefaultSize), gotPos(false), pos(-1)
2900 {}
2901
2902 wxWindow* window;
2903 wxSizer* sizer;
2904 bool gotSize;
2905 wxSize size;
2906 bool gotPos;
2907 int pos;
2908 };
2909
2910 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2911
2912 wxPySizerItemInfo info;
2913 wxSize size;
2914 wxSize* sizePtr = &size;
2915
2916 // Find out what the type of the item is
2917 // try wxWindow
2918 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2919 PyErr_Clear();
2920 info.window = NULL;
2921
2922 // try wxSizer
2923 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2924 PyErr_Clear();
2925 info.sizer = NULL;
2926
2927 // try wxSize or (w,h)
2928 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2929 info.size = *sizePtr;
2930 info.gotSize = true;
2931 }
2932
2933 // or a single int
2934 if (checkIdx && PyInt_Check(item)) {
2935 info.pos = PyInt_AsLong(item);
2936 info.gotPos = true;
2937 }
2938 }
2939 }
2940
2941 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2942 // no expected type, figure out what kind of error message to generate
2943 if ( !checkSize && !checkIdx )
2944 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2945 else if ( checkSize && !checkIdx )
2946 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2947 else if ( !checkSize && checkIdx)
2948 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2949 else
2950 // can this one happen?
2951 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2952 }
2953
2954 return info;
2955 }
2956
2957 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2958 if (!self->GetClientObject())
2959 self->SetClientObject(new wxPyOORClientData(_self));
2960 }
2961 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2962
2963 wxPyUserData* data = NULL;
2964 bool blocked = wxPyBeginBlockThreads();
2965 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2966 if ( userData && (info.window || info.sizer || info.gotSize) )
2967 data = new wxPyUserData(userData);
2968 wxPyEndBlockThreads(blocked);
2969
2970 // Now call the real Add method if a valid item type was found
2971 if ( info.window )
2972 return self->Add(info.window, proportion, flag, border, data);
2973 else if ( info.sizer )
2974 return self->Add(info.sizer, proportion, flag, border, data);
2975 else if (info.gotSize)
2976 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2977 proportion, flag, border, data);
2978 else
2979 return NULL;
2980 }
2981 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2982
2983 wxPyUserData* data = NULL;
2984 bool blocked = wxPyBeginBlockThreads();
2985 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2986 if ( userData && (info.window || info.sizer || info.gotSize) )
2987 data = new wxPyUserData(userData);
2988 wxPyEndBlockThreads(blocked);
2989
2990 // Now call the real Insert method if a valid item type was found
2991 if ( info.window )
2992 return self->Insert(before, info.window, proportion, flag, border, data);
2993 else if ( info.sizer )
2994 return self->Insert(before, info.sizer, proportion, flag, border, data);
2995 else if (info.gotSize)
2996 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2997 proportion, flag, border, data);
2998 else
2999 return NULL;
3000 }
3001 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3002
3003 wxPyUserData* data = NULL;
3004 bool blocked = wxPyBeginBlockThreads();
3005 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3006 if ( userData && (info.window || info.sizer || info.gotSize) )
3007 data = new wxPyUserData(userData);
3008 wxPyEndBlockThreads(blocked);
3009
3010 // Now call the real Prepend method if a valid item type was found
3011 if ( info.window )
3012 return self->Prepend(info.window, proportion, flag, border, data);
3013 else if ( info.sizer )
3014 return self->Prepend(info.sizer, proportion, flag, border, data);
3015 else if (info.gotSize)
3016 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3017 proportion, flag, border, data);
3018 else
3019 return NULL;
3020 }
3021 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3022 bool blocked = wxPyBeginBlockThreads();
3023 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3024 wxPyEndBlockThreads(blocked);
3025 if ( info.window )
3026 return self->Remove(info.window);
3027 else if ( info.sizer )
3028 return self->Remove(info.sizer);
3029 else if ( info.gotPos )
3030 return self->Remove(info.pos);
3031 else
3032 return false;
3033 }
3034 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3035 bool blocked = wxPyBeginBlockThreads();
3036 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3037 wxPyEndBlockThreads(blocked);
3038 if ( info.window )
3039 return self->Detach(info.window);
3040 else if ( info.sizer )
3041 return self->Detach(info.sizer);
3042 else if ( info.gotPos )
3043 return self->Detach(info.pos);
3044 else
3045 return false;
3046 }
3047 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3048 bool blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3050 wxPyEndBlockThreads(blocked);
3051 if ( info.window )
3052 return self->GetItem(info.window);
3053 else if ( info.sizer )
3054 return self->GetItem(info.sizer);
3055 else if ( info.gotPos )
3056 return self->GetItem(info.pos);
3057 else
3058 return NULL;
3059 }
3060 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3061 bool blocked = wxPyBeginBlockThreads();
3062 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3063 wxPyEndBlockThreads(blocked);
3064 if ( info.window )
3065 self->SetItemMinSize(info.window, size);
3066 else if ( info.sizer )
3067 self->SetItemMinSize(info.sizer, size);
3068 else if ( info.gotPos )
3069 self->SetItemMinSize(info.pos, size);
3070 }
3071 static PyObject *wxSizer_GetChildren(wxSizer *self){
3072 wxSizerItemList& list = self->GetChildren();
3073 return wxPy_ConvertList(&list);
3074 }
3075 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3076 bool blocked = wxPyBeginBlockThreads();
3077 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3078 wxPyEndBlockThreads(blocked);
3079 if ( info.window )
3080 return self->Show(info.window, show, recursive);
3081 else if ( info.sizer )
3082 return self->Show(info.sizer, show, recursive);
3083 else if ( info.gotPos )
3084 return self->Show(info.pos, show);
3085 else
3086 return false;
3087 }
3088 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3089 bool blocked = wxPyBeginBlockThreads();
3090 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3091 wxPyEndBlockThreads(blocked);
3092 if ( info.window )
3093 return self->IsShown(info.window);
3094 else if ( info.sizer )
3095 return self->IsShown(info.sizer);
3096 else if ( info.gotPos )
3097 return self->IsShown(info.pos);
3098 else
3099 return false;
3100 }
3101
3102 // See pyclasses.h
3103 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3104 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3105 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3106
3107
3108
3109
3110 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3111 {
3112 if (source == Py_None) {
3113 **obj = wxGBPosition(-1,-1);
3114 return true;
3115 }
3116 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3117 }
3118
3119 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3120 {
3121 if (source == Py_None) {
3122 **obj = wxGBSpan(-1,-1);
3123 return true;
3124 }
3125 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3126 }
3127
3128
3129 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3130 self->SetRow(row);
3131 self->SetCol(col);
3132 }
3133 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3134 bool blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3137 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3142 self->SetRowspan(rowspan);
3143 self->SetColspan(colspan);
3144 }
3145 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3146 bool blocked = wxPyBeginBlockThreads();
3147 PyObject* tup = PyTuple_New(2);
3148 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3149 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3150 wxPyEndBlockThreads(blocked);
3151 return tup;
3152 }
3153 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3154 wxPyUserData* data = NULL;
3155 if ( userData ) {
3156 bool blocked = wxPyBeginBlockThreads();
3157 data = new wxPyUserData(userData);
3158 wxPyEndBlockThreads(blocked);
3159 }
3160 return new wxGBSizerItem(window, pos, span, flag, border, data);
3161 }
3162 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3163 wxPyUserData* data = NULL;
3164 if ( userData ) {
3165 bool blocked = wxPyBeginBlockThreads();
3166 data = new wxPyUserData(userData);
3167 wxPyEndBlockThreads(blocked);
3168 }
3169 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3170 }
3171 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3172 wxPyUserData* data = NULL;
3173 if ( userData ) {
3174 bool blocked = wxPyBeginBlockThreads();
3175 data = new wxPyUserData(userData);
3176 wxPyEndBlockThreads(blocked);
3177 }
3178 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3179 }
3180 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3181 int row, col;
3182 self->GetEndPos(row, col);
3183 return wxGBPosition(row, col);
3184 }
3185 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3186
3187 wxPyUserData* data = NULL;
3188 bool blocked = wxPyBeginBlockThreads();
3189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3190 if ( userData && (info.window || info.sizer || info.gotSize) )
3191 data = new wxPyUserData(userData);
3192 wxPyEndBlockThreads(blocked);
3193
3194 // Now call the real Add method if a valid item type was found
3195 if ( info.window )
3196 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3197 else if ( info.sizer )
3198 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3199 else if (info.gotSize)
3200 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3201 pos, span, flag, border, data);
3202 return NULL;
3203 }
3204
3205
3206 #ifdef __cplusplus
3207 extern "C" {
3208 #endif
3209 static int _wrap_EmptyString_set(PyObject *) {
3210 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3211 return 1;
3212 }
3213
3214
3215 static PyObject *_wrap_EmptyString_get(void) {
3216 PyObject *pyobj;
3217
3218 {
3219 #if wxUSE_UNICODE
3220 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3221 #else
3222 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3223 #endif
3224 }
3225 return pyobj;
3226 }
3227
3228
3229 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3230 PyObject *resultobj;
3231 wxObject *arg1 = (wxObject *) 0 ;
3232 wxString result;
3233 PyObject * obj0 = 0 ;
3234 char *kwnames[] = {
3235 (char *) "self", NULL
3236 };
3237
3238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3240 if (SWIG_arg_fail(1)) SWIG_fail;
3241 {
3242 PyThreadState* __tstate = wxPyBeginAllowThreads();
3243 result = wxObject_GetClassName(arg1);
3244
3245 wxPyEndAllowThreads(__tstate);
3246 if (PyErr_Occurred()) SWIG_fail;
3247 }
3248 {
3249 #if wxUSE_UNICODE
3250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3251 #else
3252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3253 #endif
3254 }
3255 return resultobj;
3256 fail:
3257 return NULL;
3258 }
3259
3260
3261 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3262 PyObject *resultobj;
3263 wxObject *arg1 = (wxObject *) 0 ;
3264 PyObject * obj0 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 PyThreadState* __tstate = wxPyBeginAllowThreads();
3274 wxObject_Destroy(arg1);
3275
3276 wxPyEndAllowThreads(__tstate);
3277 if (PyErr_Occurred()) SWIG_fail;
3278 }
3279 Py_INCREF(Py_None); resultobj = Py_None;
3280 return resultobj;
3281 fail:
3282 return NULL;
3283 }
3284
3285
3286 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3287 PyObject *obj;
3288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3289 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3290 Py_INCREF(obj);
3291 return Py_BuildValue((char *)"");
3292 }
3293 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3294 PyObject *resultobj;
3295 wxSize *arg1 = (wxSize *) 0 ;
3296 int arg2 ;
3297 PyObject * obj0 = 0 ;
3298 PyObject * obj1 = 0 ;
3299 char *kwnames[] = {
3300 (char *) "self",(char *) "x", NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3305 if (SWIG_arg_fail(1)) SWIG_fail;
3306 {
3307 arg2 = (int)(SWIG_As_int(obj1));
3308 if (SWIG_arg_fail(2)) SWIG_fail;
3309 }
3310 if (arg1) (arg1)->x = arg2;
3311
3312 Py_INCREF(Py_None); resultobj = Py_None;
3313 return resultobj;
3314 fail:
3315 return NULL;
3316 }
3317
3318
3319 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxSize *arg1 = (wxSize *) 0 ;
3322 int result;
3323 PyObject * obj0 = 0 ;
3324 char *kwnames[] = {
3325 (char *) "self", NULL
3326 };
3327
3328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3330 if (SWIG_arg_fail(1)) SWIG_fail;
3331 result = (int) ((arg1)->x);
3332
3333 {
3334 resultobj = SWIG_From_int((int)(result));
3335 }
3336 return resultobj;
3337 fail:
3338 return NULL;
3339 }
3340
3341
3342 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3343 PyObject *resultobj;
3344 wxSize *arg1 = (wxSize *) 0 ;
3345 int arg2 ;
3346 PyObject * obj0 = 0 ;
3347 PyObject * obj1 = 0 ;
3348 char *kwnames[] = {
3349 (char *) "self",(char *) "y", NULL
3350 };
3351
3352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3354 if (SWIG_arg_fail(1)) SWIG_fail;
3355 {
3356 arg2 = (int)(SWIG_As_int(obj1));
3357 if (SWIG_arg_fail(2)) SWIG_fail;
3358 }
3359 if (arg1) (arg1)->y = arg2;
3360
3361 Py_INCREF(Py_None); resultobj = Py_None;
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxSize *arg1 = (wxSize *) 0 ;
3371 int result;
3372 PyObject * obj0 = 0 ;
3373 char *kwnames[] = {
3374 (char *) "self", NULL
3375 };
3376
3377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3379 if (SWIG_arg_fail(1)) SWIG_fail;
3380 result = (int) ((arg1)->y);
3381
3382 {
3383 resultobj = SWIG_From_int((int)(result));
3384 }
3385 return resultobj;
3386 fail:
3387 return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj;
3393 int arg1 = (int) 0 ;
3394 int arg2 = (int) 0 ;
3395 wxSize *result;
3396 PyObject * obj0 = 0 ;
3397 PyObject * obj1 = 0 ;
3398 char *kwnames[] = {
3399 (char *) "w",(char *) "h", NULL
3400 };
3401
3402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3403 if (obj0) {
3404 {
3405 arg1 = (int)(SWIG_As_int(obj0));
3406 if (SWIG_arg_fail(1)) SWIG_fail;
3407 }
3408 }
3409 if (obj1) {
3410 {
3411 arg2 = (int)(SWIG_As_int(obj1));
3412 if (SWIG_arg_fail(2)) SWIG_fail;
3413 }
3414 }
3415 {
3416 PyThreadState* __tstate = wxPyBeginAllowThreads();
3417 result = (wxSize *)new wxSize(arg1,arg2);
3418
3419 wxPyEndAllowThreads(__tstate);
3420 if (PyErr_Occurred()) SWIG_fail;
3421 }
3422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3423 return resultobj;
3424 fail:
3425 return NULL;
3426 }
3427
3428
3429 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3430 PyObject *resultobj;
3431 wxSize *arg1 = (wxSize *) 0 ;
3432 PyObject * obj0 = 0 ;
3433 char *kwnames[] = {
3434 (char *) "self", NULL
3435 };
3436
3437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3439 if (SWIG_arg_fail(1)) SWIG_fail;
3440 {
3441 PyThreadState* __tstate = wxPyBeginAllowThreads();
3442 delete arg1;
3443
3444 wxPyEndAllowThreads(__tstate);
3445 if (PyErr_Occurred()) SWIG_fail;
3446 }
3447 Py_INCREF(Py_None); resultobj = Py_None;
3448 return resultobj;
3449 fail:
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 wxSize *arg1 = (wxSize *) 0 ;
3457 wxSize *arg2 = 0 ;
3458 bool result;
3459 wxSize temp2 ;
3460 PyObject * obj0 = 0 ;
3461 PyObject * obj1 = 0 ;
3462 char *kwnames[] = {
3463 (char *) "self",(char *) "sz", NULL
3464 };
3465
3466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3468 if (SWIG_arg_fail(1)) SWIG_fail;
3469 {
3470 arg2 = &temp2;
3471 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3472 }
3473 {
3474 PyThreadState* __tstate = wxPyBeginAllowThreads();
3475 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3476
3477 wxPyEndAllowThreads(__tstate);
3478 if (PyErr_Occurred()) SWIG_fail;
3479 }
3480 {
3481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3482 }
3483 return resultobj;
3484 fail:
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 wxSize *arg2 = 0 ;
3493 bool result;
3494 wxSize temp2 ;
3495 PyObject * obj0 = 0 ;
3496 PyObject * obj1 = 0 ;
3497 char *kwnames[] = {
3498 (char *) "self",(char *) "sz", NULL
3499 };
3500
3501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 {
3505 arg2 = &temp2;
3506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3507 }
3508 {
3509 PyThreadState* __tstate = wxPyBeginAllowThreads();
3510 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3511
3512 wxPyEndAllowThreads(__tstate);
3513 if (PyErr_Occurred()) SWIG_fail;
3514 }
3515 {
3516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3517 }
3518 return resultobj;
3519 fail:
3520 return NULL;
3521 }
3522
3523
3524 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3525 PyObject *resultobj;
3526 wxSize *arg1 = (wxSize *) 0 ;
3527 wxSize *arg2 = 0 ;
3528 wxSize result;
3529 wxSize temp2 ;
3530 PyObject * obj0 = 0 ;
3531 PyObject * obj1 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self",(char *) "sz", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 {
3540 arg2 = &temp2;
3541 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 result = (arg1)->operator +((wxSize const &)*arg2);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 {
3551 wxSize * resultptr;
3552 resultptr = new wxSize((wxSize &)(result));
3553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3554 }
3555 return resultobj;
3556 fail:
3557 return NULL;
3558 }
3559
3560
3561 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3562 PyObject *resultobj;
3563 wxSize *arg1 = (wxSize *) 0 ;
3564 wxSize *arg2 = 0 ;
3565 wxSize result;
3566 wxSize temp2 ;
3567 PyObject * obj0 = 0 ;
3568 PyObject * obj1 = 0 ;
3569 char *kwnames[] = {
3570 (char *) "self",(char *) "sz", NULL
3571 };
3572
3573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3575 if (SWIG_arg_fail(1)) SWIG_fail;
3576 {
3577 arg2 = &temp2;
3578 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3579 }
3580 {
3581 PyThreadState* __tstate = wxPyBeginAllowThreads();
3582 result = (arg1)->operator -((wxSize const &)*arg2);
3583
3584 wxPyEndAllowThreads(__tstate);
3585 if (PyErr_Occurred()) SWIG_fail;
3586 }
3587 {
3588 wxSize * resultptr;
3589 resultptr = new wxSize((wxSize &)(result));
3590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3591 }
3592 return resultobj;
3593 fail:
3594 return NULL;
3595 }
3596
3597
3598 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3599 PyObject *resultobj;
3600 wxSize *arg1 = (wxSize *) 0 ;
3601 wxSize *arg2 = 0 ;
3602 wxSize temp2 ;
3603 PyObject * obj0 = 0 ;
3604 PyObject * obj1 = 0 ;
3605 char *kwnames[] = {
3606 (char *) "self",(char *) "sz", NULL
3607 };
3608
3609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3611 if (SWIG_arg_fail(1)) SWIG_fail;
3612 {
3613 arg2 = &temp2;
3614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3615 }
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 (arg1)->IncTo((wxSize const &)*arg2);
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 Py_INCREF(Py_None); resultobj = Py_None;
3624 return resultobj;
3625 fail:
3626 return NULL;
3627 }
3628
3629
3630 static PyObject *_wrap_Size_DecTo(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_DecTo",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)->DecTo((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_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 wxSize *arg1 = (wxSize *) 0 ;
3665 int arg2 ;
3666 int arg3 ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 PyObject * obj2 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "self",(char *) "w",(char *) "h", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 {
3678 arg2 = (int)(SWIG_As_int(obj1));
3679 if (SWIG_arg_fail(2)) SWIG_fail;
3680 }
3681 {
3682 arg3 = (int)(SWIG_As_int(obj2));
3683 if (SWIG_arg_fail(3)) SWIG_fail;
3684 }
3685 {
3686 PyThreadState* __tstate = wxPyBeginAllowThreads();
3687 (arg1)->Set(arg2,arg3);
3688
3689 wxPyEndAllowThreads(__tstate);
3690 if (PyErr_Occurred()) SWIG_fail;
3691 }
3692 Py_INCREF(Py_None); resultobj = Py_None;
3693 return resultobj;
3694 fail:
3695 return NULL;
3696 }
3697
3698
3699 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3700 PyObject *resultobj;
3701 wxSize *arg1 = (wxSize *) 0 ;
3702 int arg2 ;
3703 PyObject * obj0 = 0 ;
3704 PyObject * obj1 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "self",(char *) "w", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 {
3713 arg2 = (int)(SWIG_As_int(obj1));
3714 if (SWIG_arg_fail(2)) SWIG_fail;
3715 }
3716 {
3717 PyThreadState* __tstate = wxPyBeginAllowThreads();
3718 (arg1)->SetWidth(arg2);
3719
3720 wxPyEndAllowThreads(__tstate);
3721 if (PyErr_Occurred()) SWIG_fail;
3722 }
3723 Py_INCREF(Py_None); resultobj = Py_None;
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3731 PyObject *resultobj;
3732 wxSize *arg1 = (wxSize *) 0 ;
3733 int arg2 ;
3734 PyObject * obj0 = 0 ;
3735 PyObject * obj1 = 0 ;
3736 char *kwnames[] = {
3737 (char *) "self",(char *) "h", NULL
3738 };
3739
3740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3742 if (SWIG_arg_fail(1)) SWIG_fail;
3743 {
3744 arg2 = (int)(SWIG_As_int(obj1));
3745 if (SWIG_arg_fail(2)) SWIG_fail;
3746 }
3747 {
3748 PyThreadState* __tstate = wxPyBeginAllowThreads();
3749 (arg1)->SetHeight(arg2);
3750
3751 wxPyEndAllowThreads(__tstate);
3752 if (PyErr_Occurred()) SWIG_fail;
3753 }
3754 Py_INCREF(Py_None); resultobj = Py_None;
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 wxSize *arg1 = (wxSize *) 0 ;
3764 int result;
3765 PyObject * obj0 = 0 ;
3766 char *kwnames[] = {
3767 (char *) "self", NULL
3768 };
3769
3770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3772 if (SWIG_arg_fail(1)) SWIG_fail;
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 result = (int)((wxSize const *)arg1)->GetWidth();
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 {
3781 resultobj = SWIG_From_int((int)(result));
3782 }
3783 return resultobj;
3784 fail:
3785 return NULL;
3786 }
3787
3788
3789 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj;
3791 wxSize *arg1 = (wxSize *) 0 ;
3792 int result;
3793 PyObject * obj0 = 0 ;
3794 char *kwnames[] = {
3795 (char *) "self", NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3800 if (SWIG_arg_fail(1)) SWIG_fail;
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 result = (int)((wxSize const *)arg1)->GetHeight();
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 {
3809 resultobj = SWIG_From_int((int)(result));
3810 }
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 wxSize *arg1 = (wxSize *) 0 ;
3820 bool result;
3821 PyObject * obj0 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "self", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3828 if (SWIG_arg_fail(1)) SWIG_fail;
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 {
3837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3838 }
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj;
3847 wxSize *arg1 = (wxSize *) 0 ;
3848 wxSize *arg2 = 0 ;
3849 wxSize temp2 ;
3850 PyObject * obj0 = 0 ;
3851 PyObject * obj1 = 0 ;
3852 char *kwnames[] = {
3853 (char *) "self",(char *) "size", NULL
3854 };
3855
3856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3858 if (SWIG_arg_fail(1)) SWIG_fail;
3859 {
3860 arg2 = &temp2;
3861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3862 }
3863 {
3864 PyThreadState* __tstate = wxPyBeginAllowThreads();
3865 (arg1)->SetDefaults((wxSize const &)*arg2);
3866
3867 wxPyEndAllowThreads(__tstate);
3868 if (PyErr_Occurred()) SWIG_fail;
3869 }
3870 Py_INCREF(Py_None); resultobj = Py_None;
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 wxSize *arg1 = (wxSize *) 0 ;
3880 PyObject *result;
3881 PyObject * obj0 = 0 ;
3882 char *kwnames[] = {
3883 (char *) "self", NULL
3884 };
3885
3886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3888 if (SWIG_arg_fail(1)) SWIG_fail;
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = (PyObject *)wxSize_Get(arg1);
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 resultobj = result;
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3904 PyObject *obj;
3905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3906 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3907 Py_INCREF(obj);
3908 return Py_BuildValue((char *)"");
3909 }
3910 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3913 double arg2 ;
3914 PyObject * obj0 = 0 ;
3915 PyObject * obj1 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "self",(char *) "x", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3922 if (SWIG_arg_fail(1)) SWIG_fail;
3923 {
3924 arg2 = (double)(SWIG_As_double(obj1));
3925 if (SWIG_arg_fail(2)) SWIG_fail;
3926 }
3927 if (arg1) (arg1)->x = arg2;
3928
3929 Py_INCREF(Py_None); resultobj = Py_None;
3930 return resultobj;
3931 fail:
3932 return NULL;
3933 }
3934
3935
3936 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3939 double result;
3940 PyObject * obj0 = 0 ;
3941 char *kwnames[] = {
3942 (char *) "self", NULL
3943 };
3944
3945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3947 if (SWIG_arg_fail(1)) SWIG_fail;
3948 result = (double) ((arg1)->x);
3949
3950 {
3951 resultobj = SWIG_From_double((double)(result));
3952 }
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3962 double arg2 ;
3963 PyObject * obj0 = 0 ;
3964 PyObject * obj1 = 0 ;
3965 char *kwnames[] = {
3966 (char *) "self",(char *) "y", NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3971 if (SWIG_arg_fail(1)) SWIG_fail;
3972 {
3973 arg2 = (double)(SWIG_As_double(obj1));
3974 if (SWIG_arg_fail(2)) SWIG_fail;
3975 }
3976 if (arg1) (arg1)->y = arg2;
3977
3978 Py_INCREF(Py_None); resultobj = Py_None;
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3988 double result;
3989 PyObject * obj0 = 0 ;
3990 char *kwnames[] = {
3991 (char *) "self", NULL
3992 };
3993
3994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3996 if (SWIG_arg_fail(1)) SWIG_fail;
3997 result = (double) ((arg1)->y);
3998
3999 {
4000 resultobj = SWIG_From_double((double)(result));
4001 }
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 double arg1 = (double) 0.0 ;
4011 double arg2 = (double) 0.0 ;
4012 wxRealPoint *result;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 char *kwnames[] = {
4016 (char *) "x",(char *) "y", NULL
4017 };
4018
4019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4020 if (obj0) {
4021 {
4022 arg1 = (double)(SWIG_As_double(obj0));
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 }
4025 }
4026 if (obj1) {
4027 {
4028 arg2 = (double)(SWIG_As_double(obj1));
4029 if (SWIG_arg_fail(2)) SWIG_fail;
4030 }
4031 }
4032 {
4033 PyThreadState* __tstate = wxPyBeginAllowThreads();
4034 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4035
4036 wxPyEndAllowThreads(__tstate);
4037 if (PyErr_Occurred()) SWIG_fail;
4038 }
4039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4040 return resultobj;
4041 fail:
4042 return NULL;
4043 }
4044
4045
4046 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4049 PyObject * obj0 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "self", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4056 if (SWIG_arg_fail(1)) SWIG_fail;
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 delete arg1;
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 Py_INCREF(Py_None); resultobj = Py_None;
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
4071 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj;
4073 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4074 wxRealPoint *arg2 = 0 ;
4075 bool result;
4076 wxRealPoint temp2 ;
4077 PyObject * obj0 = 0 ;
4078 PyObject * obj1 = 0 ;
4079 char *kwnames[] = {
4080 (char *) "self",(char *) "pt", NULL
4081 };
4082
4083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4085 if (SWIG_arg_fail(1)) SWIG_fail;
4086 {
4087 arg2 = &temp2;
4088 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4089 }
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 {
4098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4099 }
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 wxRealPoint *arg2 = 0 ;
4110 bool result;
4111 wxRealPoint temp2 ;
4112 PyObject * obj0 = 0 ;
4113 PyObject * obj1 = 0 ;
4114 char *kwnames[] = {
4115 (char *) "self",(char *) "pt", NULL
4116 };
4117
4118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 {
4122 arg2 = &temp2;
4123 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4124 }
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4128
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 {
4133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4134 }
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4144 wxRealPoint *arg2 = 0 ;
4145 wxRealPoint result;
4146 wxRealPoint temp2 ;
4147 PyObject * obj0 = 0 ;
4148 PyObject * obj1 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "self",(char *) "pt", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4155 if (SWIG_arg_fail(1)) SWIG_fail;
4156 {
4157 arg2 = &temp2;
4158 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 {
4168 wxRealPoint * resultptr;
4169 resultptr = new wxRealPoint((wxRealPoint &)(result));
4170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4171 }
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4181 wxRealPoint *arg2 = 0 ;
4182 wxRealPoint result;
4183 wxRealPoint temp2 ;
4184 PyObject * obj0 = 0 ;
4185 PyObject * obj1 = 0 ;
4186 char *kwnames[] = {
4187 (char *) "self",(char *) "pt", NULL
4188 };
4189
4190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 {
4194 arg2 = &temp2;
4195 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4196 }
4197 {
4198 PyThreadState* __tstate = wxPyBeginAllowThreads();
4199 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4200
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 {
4205 wxRealPoint * resultptr;
4206 resultptr = new wxRealPoint((wxRealPoint &)(result));
4207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4208 }
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4216 PyObject *resultobj;
4217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4218 double arg2 ;
4219 double arg3 ;
4220 PyObject * obj0 = 0 ;
4221 PyObject * obj1 = 0 ;
4222 PyObject * obj2 = 0 ;
4223 char *kwnames[] = {
4224 (char *) "self",(char *) "x",(char *) "y", NULL
4225 };
4226
4227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4229 if (SWIG_arg_fail(1)) SWIG_fail;
4230 {
4231 arg2 = (double)(SWIG_As_double(obj1));
4232 if (SWIG_arg_fail(2)) SWIG_fail;
4233 }
4234 {
4235 arg3 = (double)(SWIG_As_double(obj2));
4236 if (SWIG_arg_fail(3)) SWIG_fail;
4237 }
4238 {
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 wxRealPoint_Set(arg1,arg2,arg3);
4241
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 Py_INCREF(Py_None); resultobj = Py_None;
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4255 PyObject *result;
4256 PyObject * obj0 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = (PyObject *)wxRealPoint_Get(arg1);
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 resultobj = result;
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4279 PyObject *obj;
4280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4281 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4282 Py_INCREF(obj);
4283 return Py_BuildValue((char *)"");
4284 }
4285 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj;
4287 wxPoint *arg1 = (wxPoint *) 0 ;
4288 int arg2 ;
4289 PyObject * obj0 = 0 ;
4290 PyObject * obj1 = 0 ;
4291 char *kwnames[] = {
4292 (char *) "self",(char *) "x", NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4297 if (SWIG_arg_fail(1)) SWIG_fail;
4298 {
4299 arg2 = (int)(SWIG_As_int(obj1));
4300 if (SWIG_arg_fail(2)) SWIG_fail;
4301 }
4302 if (arg1) (arg1)->x = arg2;
4303
4304 Py_INCREF(Py_None); resultobj = Py_None;
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxPoint *arg1 = (wxPoint *) 0 ;
4314 int result;
4315 PyObject * obj0 = 0 ;
4316 char *kwnames[] = {
4317 (char *) "self", NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4322 if (SWIG_arg_fail(1)) SWIG_fail;
4323 result = (int) ((arg1)->x);
4324
4325 {
4326 resultobj = SWIG_From_int((int)(result));
4327 }
4328 return resultobj;
4329 fail:
4330 return NULL;
4331 }
4332
4333
4334 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4335 PyObject *resultobj;
4336 wxPoint *arg1 = (wxPoint *) 0 ;
4337 int arg2 ;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4340 char *kwnames[] = {
4341 (char *) "self",(char *) "y", NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4346 if (SWIG_arg_fail(1)) SWIG_fail;
4347 {
4348 arg2 = (int)(SWIG_As_int(obj1));
4349 if (SWIG_arg_fail(2)) SWIG_fail;
4350 }
4351 if (arg1) (arg1)->y = arg2;
4352
4353 Py_INCREF(Py_None); resultobj = Py_None;
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxPoint *arg1 = (wxPoint *) 0 ;
4363 int result;
4364 PyObject * obj0 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "self", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(1)) SWIG_fail;
4372 result = (int) ((arg1)->y);
4373
4374 {
4375 resultobj = SWIG_From_int((int)(result));
4376 }
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj;
4385 int arg1 = (int) 0 ;
4386 int arg2 = (int) 0 ;
4387 wxPoint *result;
4388 PyObject * obj0 = 0 ;
4389 PyObject * obj1 = 0 ;
4390 char *kwnames[] = {
4391 (char *) "x",(char *) "y", NULL
4392 };
4393
4394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4395 if (obj0) {
4396 {
4397 arg1 = (int)(SWIG_As_int(obj0));
4398 if (SWIG_arg_fail(1)) SWIG_fail;
4399 }
4400 }
4401 if (obj1) {
4402 {
4403 arg2 = (int)(SWIG_As_int(obj1));
4404 if (SWIG_arg_fail(2)) SWIG_fail;
4405 }
4406 }
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = (wxPoint *)new wxPoint(arg1,arg2);
4410
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4415 return resultobj;
4416 fail:
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 wxPoint *arg1 = (wxPoint *) 0 ;
4424 PyObject * obj0 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "self", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(1)) SWIG_fail;
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 delete arg1;
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 Py_INCREF(Py_None); resultobj = Py_None;
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxPoint *arg1 = (wxPoint *) 0 ;
4449 wxPoint *arg2 = 0 ;
4450 bool result;
4451 wxPoint temp2 ;
4452 PyObject * obj0 = 0 ;
4453 PyObject * obj1 = 0 ;
4454 char *kwnames[] = {
4455 (char *) "self",(char *) "pt", NULL
4456 };
4457
4458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4460 if (SWIG_arg_fail(1)) SWIG_fail;
4461 {
4462 arg2 = &temp2;
4463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4464 }
4465 {
4466 PyThreadState* __tstate = wxPyBeginAllowThreads();
4467 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4468
4469 wxPyEndAllowThreads(__tstate);
4470 if (PyErr_Occurred()) SWIG_fail;
4471 }
4472 {
4473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4474 }
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 wxPoint *arg2 = 0 ;
4485 bool result;
4486 wxPoint temp2 ;
4487 PyObject * obj0 = 0 ;
4488 PyObject * obj1 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "self",(char *) "pt", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4495 if (SWIG_arg_fail(1)) SWIG_fail;
4496 {
4497 arg2 = &temp2;
4498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4499 }
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4503
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4509 }
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxPoint *arg1 = (wxPoint *) 0 ;
4519 wxPoint *arg2 = 0 ;
4520 wxPoint result;
4521 wxPoint temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "pt", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = (arg1)->operator +((wxPoint const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 wxPoint * resultptr;
4544 resultptr = new wxPoint((wxPoint &)(result));
4545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4546 }
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj;
4555 wxPoint *arg1 = (wxPoint *) 0 ;
4556 wxPoint *arg2 = 0 ;
4557 wxPoint result;
4558 wxPoint temp2 ;
4559 PyObject * obj0 = 0 ;
4560 PyObject * obj1 = 0 ;
4561 char *kwnames[] = {
4562 (char *) "self",(char *) "pt", NULL
4563 };
4564
4565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4567 if (SWIG_arg_fail(1)) SWIG_fail;
4568 {
4569 arg2 = &temp2;
4570 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4571 }
4572 {
4573 PyThreadState* __tstate = wxPyBeginAllowThreads();
4574 result = (arg1)->operator -((wxPoint const &)*arg2);
4575
4576 wxPyEndAllowThreads(__tstate);
4577 if (PyErr_Occurred()) SWIG_fail;
4578 }
4579 {
4580 wxPoint * resultptr;
4581 resultptr = new wxPoint((wxPoint &)(result));
4582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4583 }
4584 return resultobj;
4585 fail:
4586 return NULL;
4587 }
4588
4589
4590 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4591 PyObject *resultobj;
4592 wxPoint *arg1 = (wxPoint *) 0 ;
4593 wxPoint *arg2 = 0 ;
4594 wxPoint *result;
4595 wxPoint temp2 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char *kwnames[] = {
4599 (char *) "self",(char *) "pt", NULL
4600 };
4601
4602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4604 if (SWIG_arg_fail(1)) SWIG_fail;
4605 {
4606 arg2 = &temp2;
4607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4608 }
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 {
4612 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4613 result = (wxPoint *) &_result_ref;
4614 }
4615
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj;
4628 wxPoint *arg1 = (wxPoint *) 0 ;
4629 wxPoint *arg2 = 0 ;
4630 wxPoint *result;
4631 wxPoint temp2 ;
4632 PyObject * obj0 = 0 ;
4633 PyObject * obj1 = 0 ;
4634 char *kwnames[] = {
4635 (char *) "self",(char *) "pt", NULL
4636 };
4637
4638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4640 if (SWIG_arg_fail(1)) SWIG_fail;
4641 {
4642 arg2 = &temp2;
4643 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4644 }
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 {
4648 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4649 result = (wxPoint *) &_result_ref;
4650 }
4651
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxPoint *arg1 = (wxPoint *) 0 ;
4665 long arg2 ;
4666 long arg3 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 PyObject * obj2 = 0 ;
4670 char *kwnames[] = {
4671 (char *) "self",(char *) "x",(char *) "y", NULL
4672 };
4673
4674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(1)) SWIG_fail;
4677 {
4678 arg2 = (long)(SWIG_As_long(obj1));
4679 if (SWIG_arg_fail(2)) SWIG_fail;
4680 }
4681 {
4682 arg3 = (long)(SWIG_As_long(obj2));
4683 if (SWIG_arg_fail(3)) SWIG_fail;
4684 }
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 wxPoint_Set(arg1,arg2,arg3);
4688
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 Py_INCREF(Py_None); resultobj = Py_None;
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj;
4701 wxPoint *arg1 = (wxPoint *) 0 ;
4702 PyObject *result;
4703 PyObject * obj0 = 0 ;
4704 char *kwnames[] = {
4705 (char *) "self", NULL
4706 };
4707
4708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4710 if (SWIG_arg_fail(1)) SWIG_fail;
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 result = (PyObject *)wxPoint_Get(arg1);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 resultobj = result;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4726 PyObject *obj;
4727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4728 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4729 Py_INCREF(obj);
4730 return Py_BuildValue((char *)"");
4731 }
4732 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4733 PyObject *resultobj;
4734 int arg1 = (int) 0 ;
4735 int arg2 = (int) 0 ;
4736 int arg3 = (int) 0 ;
4737 int arg4 = (int) 0 ;
4738 wxRect *result;
4739 PyObject * obj0 = 0 ;
4740 PyObject * obj1 = 0 ;
4741 PyObject * obj2 = 0 ;
4742 PyObject * obj3 = 0 ;
4743 char *kwnames[] = {
4744 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4745 };
4746
4747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4748 if (obj0) {
4749 {
4750 arg1 = (int)(SWIG_As_int(obj0));
4751 if (SWIG_arg_fail(1)) SWIG_fail;
4752 }
4753 }
4754 if (obj1) {
4755 {
4756 arg2 = (int)(SWIG_As_int(obj1));
4757 if (SWIG_arg_fail(2)) SWIG_fail;
4758 }
4759 }
4760 if (obj2) {
4761 {
4762 arg3 = (int)(SWIG_As_int(obj2));
4763 if (SWIG_arg_fail(3)) SWIG_fail;
4764 }
4765 }
4766 if (obj3) {
4767 {
4768 arg4 = (int)(SWIG_As_int(obj3));
4769 if (SWIG_arg_fail(4)) SWIG_fail;
4770 }
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4775
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4780 return resultobj;
4781 fail:
4782 return NULL;
4783 }
4784
4785
4786 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4787 PyObject *resultobj;
4788 wxPoint *arg1 = 0 ;
4789 wxPoint *arg2 = 0 ;
4790 wxRect *result;
4791 wxPoint temp1 ;
4792 wxPoint temp2 ;
4793 PyObject * obj0 = 0 ;
4794 PyObject * obj1 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "topLeft",(char *) "bottomRight", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4800 {
4801 arg1 = &temp1;
4802 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4803 }
4804 {
4805 arg2 = &temp2;
4806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4807 }
4808 {
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4811
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4816 return resultobj;
4817 fail:
4818 return NULL;
4819 }
4820
4821
4822 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4823 PyObject *resultobj;
4824 wxPoint *arg1 = 0 ;
4825 wxSize *arg2 = 0 ;
4826 wxRect *result;
4827 wxPoint temp1 ;
4828 wxSize temp2 ;
4829 PyObject * obj0 = 0 ;
4830 PyObject * obj1 = 0 ;
4831 char *kwnames[] = {
4832 (char *) "pos",(char *) "size", NULL
4833 };
4834
4835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4836 {
4837 arg1 = &temp1;
4838 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4839 }
4840 {
4841 arg2 = &temp2;
4842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4843 }
4844 {
4845 PyThreadState* __tstate = wxPyBeginAllowThreads();
4846 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4847
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj;
4860 wxSize *arg1 = 0 ;
4861 wxRect *result;
4862 wxSize temp1 ;
4863 PyObject * obj0 = 0 ;
4864 char *kwnames[] = {
4865 (char *) "size", NULL
4866 };
4867
4868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4869 {
4870 arg1 = &temp1;
4871 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4872 }
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4876
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4888 PyObject *resultobj;
4889 wxRect *arg1 = (wxRect *) 0 ;
4890 PyObject * obj0 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "self", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4897 if (SWIG_arg_fail(1)) SWIG_fail;
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 delete arg1;
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 Py_INCREF(Py_None); resultobj = Py_None;
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxRect *arg1 = (wxRect *) 0 ;
4915 int result;
4916 PyObject * obj0 = 0 ;
4917 char *kwnames[] = {
4918 (char *) "self", NULL
4919 };
4920
4921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(1)) SWIG_fail;
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 result = (int)((wxRect const *)arg1)->GetX();
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 {
4932 resultobj = SWIG_From_int((int)(result));
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj;
4942 wxRect *arg1 = (wxRect *) 0 ;
4943 int arg2 ;
4944 PyObject * obj0 = 0 ;
4945 PyObject * obj1 = 0 ;
4946 char *kwnames[] = {
4947 (char *) "self",(char *) "x", NULL
4948 };
4949
4950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4952 if (SWIG_arg_fail(1)) SWIG_fail;
4953 {
4954 arg2 = (int)(SWIG_As_int(obj1));
4955 if (SWIG_arg_fail(2)) SWIG_fail;
4956 }
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 (arg1)->SetX(arg2);
4960
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 Py_INCREF(Py_None); resultobj = Py_None;
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4972 PyObject *resultobj;
4973 wxRect *arg1 = (wxRect *) 0 ;
4974 int result;
4975 PyObject * obj0 = 0 ;
4976 char *kwnames[] = {
4977 (char *) "self", NULL
4978 };
4979
4980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4982 if (SWIG_arg_fail(1)) SWIG_fail;
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (int)(arg1)->GetY();
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = SWIG_From_int((int)(result));
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj;
5001 wxRect *arg1 = (wxRect *) 0 ;
5002 int arg2 ;
5003 PyObject * obj0 = 0 ;
5004 PyObject * obj1 = 0 ;
5005 char *kwnames[] = {
5006 (char *) "self",(char *) "y", NULL
5007 };
5008
5009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5011 if (SWIG_arg_fail(1)) SWIG_fail;
5012 {
5013 arg2 = (int)(SWIG_As_int(obj1));
5014 if (SWIG_arg_fail(2)) SWIG_fail;
5015 }
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 (arg1)->SetY(arg2);
5019
5020 wxPyEndAllowThreads(__tstate);
5021 if (PyErr_Occurred()) SWIG_fail;
5022 }
5023 Py_INCREF(Py_None); resultobj = Py_None;
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj;
5032 wxRect *arg1 = (wxRect *) 0 ;
5033 int result;
5034 PyObject * obj0 = 0 ;
5035 char *kwnames[] = {
5036 (char *) "self", NULL
5037 };
5038
5039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5041 if (SWIG_arg_fail(1)) SWIG_fail;
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 result = (int)((wxRect const *)arg1)->GetWidth();
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 resultobj = SWIG_From_int((int)(result));
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj;
5060 wxRect *arg1 = (wxRect *) 0 ;
5061 int arg2 ;
5062 PyObject * obj0 = 0 ;
5063 PyObject * obj1 = 0 ;
5064 char *kwnames[] = {
5065 (char *) "self",(char *) "w", NULL
5066 };
5067
5068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5070 if (SWIG_arg_fail(1)) SWIG_fail;
5071 {
5072 arg2 = (int)(SWIG_As_int(obj1));
5073 if (SWIG_arg_fail(2)) SWIG_fail;
5074 }
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 (arg1)->SetWidth(arg2);
5078
5079 wxPyEndAllowThreads(__tstate);
5080 if (PyErr_Occurred()) SWIG_fail;
5081 }
5082 Py_INCREF(Py_None); resultobj = Py_None;
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5090 PyObject *resultobj;
5091 wxRect *arg1 = (wxRect *) 0 ;
5092 int result;
5093 PyObject * obj0 = 0 ;
5094 char *kwnames[] = {
5095 (char *) "self", NULL
5096 };
5097
5098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5100 if (SWIG_arg_fail(1)) SWIG_fail;
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = (int)((wxRect const *)arg1)->GetHeight();
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 {
5109 resultobj = SWIG_From_int((int)(result));
5110 }
5111 return resultobj;
5112 fail:
5113 return NULL;
5114 }
5115
5116
5117 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj;
5119 wxRect *arg1 = (wxRect *) 0 ;
5120 int arg2 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char *kwnames[] = {
5124 (char *) "self",(char *) "h", NULL
5125 };
5126
5127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5129 if (SWIG_arg_fail(1)) SWIG_fail;
5130 {
5131 arg2 = (int)(SWIG_As_int(obj1));
5132 if (SWIG_arg_fail(2)) SWIG_fail;
5133 }
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 (arg1)->SetHeight(arg2);
5137
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 Py_INCREF(Py_None); resultobj = Py_None;
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj;
5150 wxRect *arg1 = (wxRect *) 0 ;
5151 wxPoint result;
5152 PyObject * obj0 = 0 ;
5153 char *kwnames[] = {
5154 (char *) "self", NULL
5155 };
5156
5157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5159 if (SWIG_arg_fail(1)) SWIG_fail;
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 result = ((wxRect const *)arg1)->GetPosition();
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 wxPoint * resultptr;
5169 resultptr = new wxPoint((wxPoint &)(result));
5170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5171 }
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5179 PyObject *resultobj;
5180 wxRect *arg1 = (wxRect *) 0 ;
5181 wxPoint *arg2 = 0 ;
5182 wxPoint temp2 ;
5183 PyObject * obj0 = 0 ;
5184 PyObject * obj1 = 0 ;
5185 char *kwnames[] = {
5186 (char *) "self",(char *) "p", NULL
5187 };
5188
5189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5195 }
5196 {
5197 PyThreadState* __tstate = wxPyBeginAllowThreads();
5198 (arg1)->SetPosition((wxPoint const &)*arg2);
5199
5200 wxPyEndAllowThreads(__tstate);
5201 if (PyErr_Occurred()) SWIG_fail;
5202 }
5203 Py_INCREF(Py_None); resultobj = Py_None;
5204 return resultobj;
5205 fail:
5206 return NULL;
5207 }
5208
5209
5210 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5211 PyObject *resultobj;
5212 wxRect *arg1 = (wxRect *) 0 ;
5213 wxSize result;
5214 PyObject * obj0 = 0 ;
5215 char *kwnames[] = {
5216 (char *) "self", NULL
5217 };
5218
5219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5221 if (SWIG_arg_fail(1)) SWIG_fail;
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 result = ((wxRect const *)arg1)->GetSize();
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 {
5230 wxSize * resultptr;
5231 resultptr = new wxSize((wxSize &)(result));
5232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5233 }
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj;
5242 wxRect *arg1 = (wxRect *) 0 ;
5243 wxSize *arg2 = 0 ;
5244 wxSize temp2 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char *kwnames[] = {
5248 (char *) "self",(char *) "s", NULL
5249 };
5250
5251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5257 }
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 (arg1)->SetSize((wxSize const &)*arg2);
5261
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 Py_INCREF(Py_None); resultobj = Py_None;
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj;
5274 wxRect *arg1 = (wxRect *) 0 ;
5275 wxPoint result;
5276 PyObject * obj0 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 result = ((wxRect const *)arg1)->GetTopLeft();
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 {
5292 wxPoint * resultptr;
5293 resultptr = new wxPoint((wxPoint &)(result));
5294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5295 }
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxRect *arg1 = (wxRect *) 0 ;
5305 wxPoint *arg2 = 0 ;
5306 wxPoint temp2 ;
5307 PyObject * obj0 = 0 ;
5308 PyObject * obj1 = 0 ;
5309 char *kwnames[] = {
5310 (char *) "self",(char *) "p", NULL
5311 };
5312
5313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
5318 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5319 }
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5323
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 Py_INCREF(Py_None); resultobj = Py_None;
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj;
5336 wxRect *arg1 = (wxRect *) 0 ;
5337 wxPoint result;
5338 PyObject * obj0 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 PyThreadState* __tstate = wxPyBeginAllowThreads();
5348 result = ((wxRect const *)arg1)->GetBottomRight();
5349
5350 wxPyEndAllowThreads(__tstate);
5351 if (PyErr_Occurred()) SWIG_fail;
5352 }
5353 {
5354 wxPoint * resultptr;
5355 resultptr = new wxPoint((wxPoint &)(result));
5356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5357 }
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxRect *arg1 = (wxRect *) 0 ;
5367 wxPoint *arg2 = 0 ;
5368 wxPoint temp2 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char *kwnames[] = {
5372 (char *) "self",(char *) "p", NULL
5373 };
5374
5375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5377 if (SWIG_arg_fail(1)) SWIG_fail;
5378 {
5379 arg2 = &temp2;
5380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5381 }
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5385
5386 wxPyEndAllowThreads(__tstate);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 Py_INCREF(Py_None); resultobj = Py_None;
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj;
5398 wxRect *arg1 = (wxRect *) 0 ;
5399 int result;
5400 PyObject * obj0 = 0 ;
5401 char *kwnames[] = {
5402 (char *) "self", NULL
5403 };
5404
5405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5407 if (SWIG_arg_fail(1)) SWIG_fail;
5408 {
5409 PyThreadState* __tstate = wxPyBeginAllowThreads();
5410 result = (int)((wxRect const *)arg1)->GetLeft();
5411
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 resultobj = SWIG_From_int((int)(result));
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj;
5426 wxRect *arg1 = (wxRect *) 0 ;
5427 int result;
5428 PyObject * obj0 = 0 ;
5429 char *kwnames[] = {
5430 (char *) "self", NULL
5431 };
5432
5433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5435 if (SWIG_arg_fail(1)) SWIG_fail;
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = (int)((wxRect const *)arg1)->GetTop();
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 resultobj = SWIG_From_int((int)(result));
5445 }
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxRect *arg1 = (wxRect *) 0 ;
5455 int result;
5456 PyObject * obj0 = 0 ;
5457 char *kwnames[] = {
5458 (char *) "self", NULL
5459 };
5460
5461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5463 if (SWIG_arg_fail(1)) SWIG_fail;
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = (int)((wxRect const *)arg1)->GetBottom();
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 resultobj = SWIG_From_int((int)(result));
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj;
5482 wxRect *arg1 = (wxRect *) 0 ;
5483 int result;
5484 PyObject * obj0 = 0 ;
5485 char *kwnames[] = {
5486 (char *) "self", NULL
5487 };
5488
5489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5491 if (SWIG_arg_fail(1)) SWIG_fail;
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 result = (int)((wxRect const *)arg1)->GetRight();
5495
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 resultobj = SWIG_From_int((int)(result));
5501 }
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5509 PyObject *resultobj;
5510 wxRect *arg1 = (wxRect *) 0 ;
5511 int arg2 ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self",(char *) "left", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 arg2 = (int)(SWIG_As_int(obj1));
5523 if (SWIG_arg_fail(2)) SWIG_fail;
5524 }
5525 {
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 (arg1)->SetLeft(arg2);
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 Py_INCREF(Py_None); resultobj = Py_None;
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj;
5541 wxRect *arg1 = (wxRect *) 0 ;
5542 int arg2 ;
5543 PyObject * obj0 = 0 ;
5544 PyObject * obj1 = 0 ;
5545 char *kwnames[] = {
5546 (char *) "self",(char *) "right", NULL
5547 };
5548
5549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
5554 if (SWIG_arg_fail(2)) SWIG_fail;
5555 }
5556 {
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 (arg1)->SetRight(arg2);
5559
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 Py_INCREF(Py_None); resultobj = Py_None;
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5571 PyObject *resultobj;
5572 wxRect *arg1 = (wxRect *) 0 ;
5573 int arg2 ;
5574 PyObject * obj0 = 0 ;
5575 PyObject * obj1 = 0 ;
5576 char *kwnames[] = {
5577 (char *) "self",(char *) "top", NULL
5578 };
5579
5580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5582 if (SWIG_arg_fail(1)) SWIG_fail;
5583 {
5584 arg2 = (int)(SWIG_As_int(obj1));
5585 if (SWIG_arg_fail(2)) SWIG_fail;
5586 }
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 (arg1)->SetTop(arg2);
5590
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 Py_INCREF(Py_None); resultobj = Py_None;
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 wxRect *arg1 = (wxRect *) 0 ;
5604 int arg2 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 char *kwnames[] = {
5608 (char *) "self",(char *) "bottom", NULL
5609 };
5610
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5613 if (SWIG_arg_fail(1)) SWIG_fail;
5614 {
5615 arg2 = (int)(SWIG_As_int(obj1));
5616 if (SWIG_arg_fail(2)) SWIG_fail;
5617 }
5618 {
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 (arg1)->SetBottom(arg2);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj;
5634 wxRect *arg1 = (wxRect *) 0 ;
5635 int arg2 ;
5636 int arg3 ;
5637 wxRect *result;
5638 PyObject * obj0 = 0 ;
5639 PyObject * obj1 = 0 ;
5640 PyObject * obj2 = 0 ;
5641 char *kwnames[] = {
5642 (char *) "self",(char *) "dx",(char *) "dy", NULL
5643 };
5644
5645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5647 if (SWIG_arg_fail(1)) SWIG_fail;
5648 {
5649 arg2 = (int)(SWIG_As_int(obj1));
5650 if (SWIG_arg_fail(2)) SWIG_fail;
5651 }
5652 {
5653 arg3 = (int)(SWIG_As_int(obj2));
5654 if (SWIG_arg_fail(3)) SWIG_fail;
5655 }
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 {
5659 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5660 result = (wxRect *) &_result_ref;
5661 }
5662
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5674 PyObject *resultobj;
5675 wxRect *arg1 = (wxRect *) 0 ;
5676 int arg2 ;
5677 int arg3 ;
5678 wxRect *result;
5679 PyObject * obj0 = 0 ;
5680 PyObject * obj1 = 0 ;
5681 PyObject * obj2 = 0 ;
5682 char *kwnames[] = {
5683 (char *) "self",(char *) "dx",(char *) "dy", NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 {
5690 arg2 = (int)(SWIG_As_int(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 arg3 = (int)(SWIG_As_int(obj2));
5695 if (SWIG_arg_fail(3)) SWIG_fail;
5696 }
5697 {
5698 PyThreadState* __tstate = wxPyBeginAllowThreads();
5699 {
5700 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5701 result = (wxRect *) &_result_ref;
5702 }
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj;
5716 wxRect *arg1 = (wxRect *) 0 ;
5717 int arg2 ;
5718 int arg3 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 PyObject * obj2 = 0 ;
5722 char *kwnames[] = {
5723 (char *) "self",(char *) "dx",(char *) "dy", NULL
5724 };
5725
5726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5728 if (SWIG_arg_fail(1)) SWIG_fail;
5729 {
5730 arg2 = (int)(SWIG_As_int(obj1));
5731 if (SWIG_arg_fail(2)) SWIG_fail;
5732 }
5733 {
5734 arg3 = (int)(SWIG_As_int(obj2));
5735 if (SWIG_arg_fail(3)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 (arg1)->Offset(arg2,arg3);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 Py_INCREF(Py_None); resultobj = Py_None;
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5752 PyObject *resultobj;
5753 wxRect *arg1 = (wxRect *) 0 ;
5754 wxPoint *arg2 = 0 ;
5755 wxPoint temp2 ;
5756 PyObject * obj0 = 0 ;
5757 PyObject * obj1 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "self",(char *) "pt", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 {
5766 arg2 = &temp2;
5767 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 (arg1)->Offset((wxPoint const &)*arg2);
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 Py_INCREF(Py_None); resultobj = Py_None;
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxRect *arg1 = (wxRect *) 0 ;
5786 wxRect *arg2 = 0 ;
5787 wxRect result;
5788 wxRect temp2 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char *kwnames[] = {
5792 (char *) "self",(char *) "rect", NULL
5793 };
5794
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(1)) SWIG_fail;
5798 {
5799 arg2 = &temp2;
5800 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5801 }
5802 {
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 result = (arg1)->Intersect((wxRect const &)*arg2);
5805
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 {
5810 wxRect * resultptr;
5811 resultptr = new wxRect((wxRect &)(result));
5812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5813 }
5814 return resultobj;
5815 fail:
5816 return NULL;
5817 }
5818
5819
5820 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5821 PyObject *resultobj;
5822 wxRect *arg1 = (wxRect *) 0 ;
5823 wxRect *arg2 = 0 ;
5824 wxRect result;
5825 wxRect temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "rect", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 result = (arg1)->Union((wxRect const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 {
5847 wxRect * resultptr;
5848 resultptr = new wxRect((wxRect &)(result));
5849 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5850 }
5851 return resultobj;
5852 fail:
5853 return NULL;
5854 }
5855
5856
5857 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5858 PyObject *resultobj;
5859 wxRect *arg1 = (wxRect *) 0 ;
5860 wxRect *arg2 = 0 ;
5861 wxRect result;
5862 wxRect temp2 ;
5863 PyObject * obj0 = 0 ;
5864 PyObject * obj1 = 0 ;
5865 char *kwnames[] = {
5866 (char *) "self",(char *) "rect", NULL
5867 };
5868
5869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5871 if (SWIG_arg_fail(1)) SWIG_fail;
5872 {
5873 arg2 = &temp2;
5874 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5875 }
5876 {
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 wxRect * resultptr;
5885 resultptr = new wxRect((wxRect &)(result));
5886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj;
5896 wxRect *arg1 = (wxRect *) 0 ;
5897 wxRect *arg2 = 0 ;
5898 wxRect *result;
5899 wxRect temp2 ;
5900 PyObject * obj0 = 0 ;
5901 PyObject * obj1 = 0 ;
5902 char *kwnames[] = {
5903 (char *) "self",(char *) "rect", NULL
5904 };
5905
5906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5908 if (SWIG_arg_fail(1)) SWIG_fail;
5909 {
5910 arg2 = &temp2;
5911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5912 }
5913 {
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 {
5916 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5917 result = (wxRect *) &_result_ref;
5918 }
5919
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj;
5932 wxRect *arg1 = (wxRect *) 0 ;
5933 wxRect *arg2 = 0 ;
5934 bool result;
5935 wxRect temp2 ;
5936 PyObject * obj0 = 0 ;
5937 PyObject * obj1 = 0 ;
5938 char *kwnames[] = {
5939 (char *) "self",(char *) "rect", NULL
5940 };
5941
5942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5944 if (SWIG_arg_fail(1)) SWIG_fail;
5945 {
5946 arg2 = &temp2;
5947 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5958 }
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj;
5967 wxRect *arg1 = (wxRect *) 0 ;
5968 wxRect *arg2 = 0 ;
5969 bool result;
5970 wxRect temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "self",(char *) "rect", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5979 if (SWIG_arg_fail(1)) SWIG_fail;
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5987
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 {
5992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5993 }
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 int arg2 ;
6004 int arg3 ;
6005 bool result;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 PyObject * obj2 = 0 ;
6009 char *kwnames[] = {
6010 (char *) "self",(char *) "x",(char *) "y", NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6015 if (SWIG_arg_fail(1)) SWIG_fail;
6016 {
6017 arg2 = (int)(SWIG_As_int(obj1));
6018 if (SWIG_arg_fail(2)) SWIG_fail;
6019 }
6020 {
6021 arg3 = (int)(SWIG_As_int(obj2));
6022 if (SWIG_arg_fail(3)) SWIG_fail;
6023 }
6024 {
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxPoint *arg2 = 0 ;
6044 bool result;
6045 wxPoint temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "pt", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 wxRect *arg2 = 0 ;
6079 bool result;
6080 wxRect temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "rect", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 {
6091 arg2 = &temp2;
6092 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 int arg2 ;
6114 PyObject * obj0 = 0 ;
6115 PyObject * obj1 = 0 ;
6116 char *kwnames[] = {
6117 (char *) "self",(char *) "x", NULL
6118 };
6119
6120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6122 if (SWIG_arg_fail(1)) SWIG_fail;
6123 {
6124 arg2 = (int)(SWIG_As_int(obj1));
6125 if (SWIG_arg_fail(2)) SWIG_fail;
6126 }
6127 if (arg1) (arg1)->x = arg2;
6128
6129 Py_INCREF(Py_None); resultobj = Py_None;
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxRect *arg1 = (wxRect *) 0 ;
6139 int result;
6140 PyObject * obj0 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 result = (int) ((arg1)->x);
6149
6150 {
6151 resultobj = SWIG_From_int((int)(result));
6152 }
6153 return resultobj;
6154 fail:
6155 return NULL;
6156 }
6157
6158
6159 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj;
6161 wxRect *arg1 = (wxRect *) 0 ;
6162 int arg2 ;
6163 PyObject * obj0 = 0 ;
6164 PyObject * obj1 = 0 ;
6165 char *kwnames[] = {
6166 (char *) "self",(char *) "y", NULL
6167 };
6168
6169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6171 if (SWIG_arg_fail(1)) SWIG_fail;
6172 {
6173 arg2 = (int)(SWIG_As_int(obj1));
6174 if (SWIG_arg_fail(2)) SWIG_fail;
6175 }
6176 if (arg1) (arg1)->y = arg2;
6177
6178 Py_INCREF(Py_None); resultobj = Py_None;
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int result;
6189 PyObject * obj0 = 0 ;
6190 char *kwnames[] = {
6191 (char *) "self", NULL
6192 };
6193
6194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 result = (int) ((arg1)->y);
6198
6199 {
6200 resultobj = SWIG_From_int((int)(result));
6201 }
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj;
6210 wxRect *arg1 = (wxRect *) 0 ;
6211 int arg2 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 char *kwnames[] = {
6215 (char *) "self",(char *) "width", NULL
6216 };
6217
6218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6220 if (SWIG_arg_fail(1)) SWIG_fail;
6221 {
6222 arg2 = (int)(SWIG_As_int(obj1));
6223 if (SWIG_arg_fail(2)) SWIG_fail;
6224 }
6225 if (arg1) (arg1)->width = arg2;
6226
6227 Py_INCREF(Py_None); resultobj = Py_None;
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int result;
6238 PyObject * obj0 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "self", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 result = (int) ((arg1)->width);
6247
6248 {
6249 resultobj = SWIG_From_int((int)(result));
6250 }
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6258 PyObject *resultobj;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int arg2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char *kwnames[] = {
6264 (char *) "self",(char *) "height", NULL
6265 };
6266
6267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6269 if (SWIG_arg_fail(1)) SWIG_fail;
6270 {
6271 arg2 = (int)(SWIG_As_int(obj1));
6272 if (SWIG_arg_fail(2)) SWIG_fail;
6273 }
6274 if (arg1) (arg1)->height = arg2;
6275
6276 Py_INCREF(Py_None); resultobj = Py_None;
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxRect *arg1 = (wxRect *) 0 ;
6286 int result;
6287 PyObject * obj0 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 result = (int) ((arg1)->height);
6296
6297 {
6298 resultobj = SWIG_From_int((int)(result));
6299 }
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 = (int) 0 ;
6310 int arg3 = (int) 0 ;
6311 int arg4 = (int) 0 ;
6312 int arg5 = (int) 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 PyObject * obj2 = 0 ;
6316 PyObject * obj3 = 0 ;
6317 PyObject * obj4 = 0 ;
6318 char *kwnames[] = {
6319 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6320 };
6321
6322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6324 if (SWIG_arg_fail(1)) SWIG_fail;
6325 if (obj1) {
6326 {
6327 arg2 = (int)(SWIG_As_int(obj1));
6328 if (SWIG_arg_fail(2)) SWIG_fail;
6329 }
6330 }
6331 if (obj2) {
6332 {
6333 arg3 = (int)(SWIG_As_int(obj2));
6334 if (SWIG_arg_fail(3)) SWIG_fail;
6335 }
6336 }
6337 if (obj3) {
6338 {
6339 arg4 = (int)(SWIG_As_int(obj3));
6340 if (SWIG_arg_fail(4)) SWIG_fail;
6341 }
6342 }
6343 if (obj4) {
6344 {
6345 arg5 = (int)(SWIG_As_int(obj4));
6346 if (SWIG_arg_fail(5)) SWIG_fail;
6347 }
6348 }
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6352
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 PyObject *result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "self", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6374 if (SWIG_arg_fail(1)) SWIG_fail;
6375 {
6376 PyThreadState* __tstate = wxPyBeginAllowThreads();
6377 result = (PyObject *)wxRect_Get(arg1);
6378
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = result;
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6390 PyObject *obj;
6391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6392 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6393 Py_INCREF(obj);
6394 return Py_BuildValue((char *)"");
6395 }
6396 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6397 PyObject *resultobj;
6398 wxRect *arg1 = (wxRect *) 0 ;
6399 wxRect *arg2 = (wxRect *) 0 ;
6400 PyObject *result;
6401 PyObject * obj0 = 0 ;
6402 PyObject * obj1 = 0 ;
6403 char *kwnames[] = {
6404 (char *) "r1",(char *) "r2", NULL
6405 };
6406
6407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6409 if (SWIG_arg_fail(1)) SWIG_fail;
6410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(2)) SWIG_fail;
6412 {
6413 if (!wxPyCheckForApp()) SWIG_fail;
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (PyObject *)wxIntersectRect(arg1,arg2);
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = result;
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj;
6429 double arg1 = (double) 0.0 ;
6430 double arg2 = (double) 0.0 ;
6431 wxPoint2D *result;
6432 PyObject * obj0 = 0 ;
6433 PyObject * obj1 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "x",(char *) "y", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6439 if (obj0) {
6440 {
6441 arg1 = (double)(SWIG_As_double(obj0));
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 }
6444 }
6445 if (obj1) {
6446 {
6447 arg2 = (double)(SWIG_As_double(obj1));
6448 if (SWIG_arg_fail(2)) SWIG_fail;
6449 }
6450 }
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 wxPoint2D *arg1 = 0 ;
6468 wxPoint2D *result;
6469 wxPoint2D temp1 ;
6470 PyObject * obj0 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "pt", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6476 {
6477 arg1 = &temp1;
6478 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6479 }
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6483
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6488 return resultobj;
6489 fail:
6490 return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6495 PyObject *resultobj;
6496 wxPoint *arg1 = 0 ;
6497 wxPoint2D *result;
6498 wxPoint temp1 ;
6499 PyObject * obj0 = 0 ;
6500 char *kwnames[] = {
6501 (char *) "pt", NULL
6502 };
6503
6504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6505 {
6506 arg1 = &temp1;
6507 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6508 }
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6524 PyObject *resultobj;
6525 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6526 int *arg2 = (int *) 0 ;
6527 int *arg3 = (int *) 0 ;
6528 int temp2 ;
6529 int res2 = 0 ;
6530 int temp3 ;
6531 int res3 = 0 ;
6532 PyObject * obj0 = 0 ;
6533 char *kwnames[] = {
6534 (char *) "self", NULL
6535 };
6536
6537 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6538 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6541 if (SWIG_arg_fail(1)) SWIG_fail;
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6545
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 Py_INCREF(Py_None); resultobj = Py_None;
6550 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6551 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6552 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6553 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6554 return resultobj;
6555 fail:
6556 return NULL;
6557 }
6558
6559
6560 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6561 PyObject *resultobj;
6562 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6563 int *arg2 = (int *) 0 ;
6564 int *arg3 = (int *) 0 ;
6565 int temp2 ;
6566 int res2 = 0 ;
6567 int temp3 ;
6568 int res3 = 0 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "self", NULL
6572 };
6573
6574 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6575 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6578 if (SWIG_arg_fail(1)) SWIG_fail;
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 Py_INCREF(Py_None); resultobj = Py_None;
6587 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6588 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6589 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6590 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6598 PyObject *resultobj;
6599 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6600 double result;
6601 PyObject * obj0 = 0 ;
6602 char *kwnames[] = {
6603 (char *) "self", NULL
6604 };
6605
6606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6608 if (SWIG_arg_fail(1)) SWIG_fail;
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6612
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 {
6617 resultobj = SWIG_From_double((double)(result));
6618 }
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj;
6627 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6628 double result;
6629 PyObject * obj0 = 0 ;
6630 char *kwnames[] = {
6631 (char *) "self", NULL
6632 };
6633
6634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6636 if (SWIG_arg_fail(1)) SWIG_fail;
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6640
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 {
6645 resultobj = SWIG_From_double((double)(result));
6646 }
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6654 PyObject *resultobj;
6655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6656 double arg2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char *kwnames[] = {
6660 (char *) "self",(char *) "length", NULL
6661 };
6662
6663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6665 if (SWIG_arg_fail(1)) SWIG_fail;
6666 {
6667 arg2 = (double)(SWIG_As_double(obj1));
6668 if (SWIG_arg_fail(2)) SWIG_fail;
6669 }
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 (arg1)->SetVectorLength(arg2);
6673
6674 wxPyEndAllowThreads(__tstate);
6675 if (PyErr_Occurred()) SWIG_fail;
6676 }
6677 Py_INCREF(Py_None); resultobj = Py_None;
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6685 PyObject *resultobj;
6686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6687 double arg2 ;
6688 PyObject * obj0 = 0 ;
6689 PyObject * obj1 = 0 ;
6690 char *kwnames[] = {
6691 (char *) "self",(char *) "degrees", NULL
6692 };
6693
6694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) 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 arg2 = (double)(SWIG_As_double(obj1));
6699 if (SWIG_arg_fail(2)) SWIG_fail;
6700 }
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 (arg1)->SetVectorAngle(arg2);
6704
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 Py_INCREF(Py_None); resultobj = Py_None;
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj;
6717 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6718 wxPoint2D *arg2 = 0 ;
6719 double result;
6720 wxPoint2D temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char *kwnames[] = {
6724 (char *) "self",(char *) "pt", NULL
6725 };
6726
6727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6729 if (SWIG_arg_fail(1)) SWIG_fail;
6730 {
6731 arg2 = &temp2;
6732 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6737
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 {
6742 resultobj = SWIG_From_double((double)(result));
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6753 wxPoint2D *arg2 = 0 ;
6754 double result;
6755 wxPoint2D temp2 ;
6756 PyObject * obj0 = 0 ;
6757 PyObject * obj1 = 0 ;
6758 char *kwnames[] = {
6759 (char *) "self",(char *) "pt", NULL
6760 };
6761
6762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 {
6766 arg2 = &temp2;
6767 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6768 }
6769 {
6770 PyThreadState* __tstate = wxPyBeginAllowThreads();
6771 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6772
6773 wxPyEndAllowThreads(__tstate);
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 {
6777 resultobj = SWIG_From_double((double)(result));
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "vec", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "vec", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D result;
6859 PyObject * obj0 = 0 ;
6860 char *kwnames[] = {
6861 (char *) "self", NULL
6862 };
6863
6864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6866 if (SWIG_arg_fail(1)) SWIG_fail;
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = (arg1)->operator -();
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 {
6875 wxPoint2D * resultptr;
6876 resultptr = new wxPoint2D((wxPoint2D &)(result));
6877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6878 }
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj;
6887 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6888 wxPoint2D *arg2 = 0 ;
6889 wxPoint2D *result;
6890 wxPoint2D temp2 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "self",(char *) "pt", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6899 if (SWIG_arg_fail(1)) SWIG_fail;
6900 {
6901 arg2 = &temp2;
6902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6903 }
6904 {
6905 PyThreadState* __tstate = wxPyBeginAllowThreads();
6906 {
6907 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6908 result = (wxPoint2D *) &_result_ref;
6909 }
6910
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj;
6923 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6924 wxPoint2D *arg2 = 0 ;
6925 wxPoint2D *result;
6926 wxPoint2D temp2 ;
6927 PyObject * obj0 = 0 ;
6928 PyObject * obj1 = 0 ;
6929 char *kwnames[] = {
6930 (char *) "self",(char *) "pt", NULL
6931 };
6932
6933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6935 if (SWIG_arg_fail(1)) SWIG_fail;
6936 {
6937 arg2 = &temp2;
6938 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6939 }
6940 {
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 {
6943 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6944 result = (wxPoint2D *) &_result_ref;
6945 }
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj;
6959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6960 wxPoint2D *arg2 = 0 ;
6961 wxPoint2D *result;
6962 wxPoint2D temp2 ;
6963 PyObject * obj0 = 0 ;
6964 PyObject * obj1 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "self",(char *) "pt", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6971 if (SWIG_arg_fail(1)) SWIG_fail;
6972 {
6973 arg2 = &temp2;
6974 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 {
6979 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6980 result = (wxPoint2D *) &_result_ref;
6981 }
6982
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6996 wxPoint2D *arg2 = 0 ;
6997 wxPoint2D *result;
6998 wxPoint2D temp2 ;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "self",(char *) "pt", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 {
7015 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7016 result = (wxPoint2D *) &_result_ref;
7017 }
7018
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7032 wxPoint2D *arg2 = 0 ;
7033 bool result;
7034 wxPoint2D temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "pt", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7051
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7057 }
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj;
7066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7067 wxPoint2D *arg2 = 0 ;
7068 bool result;
7069 wxPoint2D temp2 ;
7070 PyObject * obj0 = 0 ;
7071 PyObject * obj1 = 0 ;
7072 char *kwnames[] = {
7073 (char *) "self",(char *) "pt", NULL
7074 };
7075
7076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7078 if (SWIG_arg_fail(1)) SWIG_fail;
7079 {
7080 arg2 = &temp2;
7081 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7082 }
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 {
7091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7092 }
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 double arg2 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 char *kwnames[] = {
7106 (char *) "self",(char *) "m_x", NULL
7107 };
7108
7109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(1)) SWIG_fail;
7112 {
7113 arg2 = (double)(SWIG_As_double(obj1));
7114 if (SWIG_arg_fail(2)) SWIG_fail;
7115 }
7116 if (arg1) (arg1)->m_x = arg2;
7117
7118 Py_INCREF(Py_None); resultobj = Py_None;
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj;
7127 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7128 double result;
7129 PyObject * obj0 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 result = (double) ((arg1)->m_x);
7138
7139 {
7140 resultobj = SWIG_From_double((double)(result));
7141 }
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj;
7150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7151 double arg2 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char *kwnames[] = {
7155 (char *) "self",(char *) "m_y", NULL
7156 };
7157
7158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7160 if (SWIG_arg_fail(1)) SWIG_fail;
7161 {
7162 arg2 = (double)(SWIG_As_double(obj1));
7163 if (SWIG_arg_fail(2)) SWIG_fail;
7164 }
7165 if (arg1) (arg1)->m_y = arg2;
7166
7167 Py_INCREF(Py_None); resultobj = Py_None;
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 double result;
7178 PyObject * obj0 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 result = (double) ((arg1)->m_y);
7187
7188 {
7189 resultobj = SWIG_From_double((double)(result));
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7200 double arg2 = (double) 0 ;
7201 double arg3 = (double) 0 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 PyObject * obj2 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self",(char *) "x",(char *) "y", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 if (obj1) {
7213 {
7214 arg2 = (double)(SWIG_As_double(obj1));
7215 if (SWIG_arg_fail(2)) SWIG_fail;
7216 }
7217 }
7218 if (obj2) {
7219 {
7220 arg3 = (double)(SWIG_As_double(obj2));
7221 if (SWIG_arg_fail(3)) SWIG_fail;
7222 }
7223 }
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 wxPoint2D_Set(arg1,arg2,arg3);
7227
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 Py_INCREF(Py_None); resultobj = Py_None;
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj;
7240 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7241 PyObject *result;
7242 PyObject * obj0 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 {
7251 PyThreadState* __tstate = wxPyBeginAllowThreads();
7252 result = (PyObject *)wxPoint2D_Get(arg1);
7253
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 resultobj = result;
7258 return resultobj;
7259 fail:
7260 return NULL;
7261 }
7262
7263
7264 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7265 PyObject *obj;
7266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7267 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7268 Py_INCREF(obj);
7269 return Py_BuildValue((char *)"");
7270 }
7271 static int _wrap_DefaultPosition_set(PyObject *) {
7272 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7273 return 1;
7274 }
7275
7276
7277 static PyObject *_wrap_DefaultPosition_get(void) {
7278 PyObject *pyobj;
7279
7280 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7281 return pyobj;
7282 }
7283
7284
7285 static int _wrap_DefaultSize_set(PyObject *) {
7286 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7287 return 1;
7288 }
7289
7290
7291 static PyObject *_wrap_DefaultSize_get(void) {
7292 PyObject *pyobj;
7293
7294 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7295 return pyobj;
7296 }
7297
7298
7299 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj;
7301 PyObject *arg1 = (PyObject *) 0 ;
7302 wxPyInputStream *result;
7303 PyObject * obj0 = 0 ;
7304 char *kwnames[] = {
7305 (char *) "p", NULL
7306 };
7307
7308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7309 arg1 = obj0;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7327 PyObject * obj0 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 delete arg1;
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 Py_INCREF(Py_None); resultobj = Py_None;
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj;
7351 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 (arg1)->close();
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->flush();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 bool result;
7403 PyObject * obj0 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)(arg1)->eof();
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 {
7419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7420 }
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj;
7429 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7430 int arg2 = (int) -1 ;
7431 PyObject *result;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self",(char *) "size", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 if (obj1) {
7442 {
7443 arg2 = (int)(SWIG_As_int(obj1));
7444 if (SWIG_arg_fail(2)) SWIG_fail;
7445 }
7446 }
7447 {
7448 PyThreadState* __tstate = wxPyBeginAllowThreads();
7449 result = (PyObject *)(arg1)->read(arg2);
7450
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 resultobj = result;
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj;
7463 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7464 int arg2 = (int) -1 ;
7465 PyObject *result;
7466 PyObject * obj0 = 0 ;
7467 PyObject * obj1 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "size", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 if (obj1) {
7476 {
7477 arg2 = (int)(SWIG_As_int(obj1));
7478 if (SWIG_arg_fail(2)) SWIG_fail;
7479 }
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (PyObject *)(arg1)->readline(arg2);
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 resultobj = result;
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj;
7497 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7498 int arg2 = (int) -1 ;
7499 PyObject *result;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "self",(char *) "sizehint", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(1)) SWIG_fail;
7509 if (obj1) {
7510 {
7511 arg2 = (int)(SWIG_As_int(obj1));
7512 if (SWIG_arg_fail(2)) SWIG_fail;
7513 }
7514 }
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 result = (PyObject *)(arg1)->readlines(arg2);
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 resultobj = result;
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj;
7531 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7532 int arg2 ;
7533 int arg3 = (int) 0 ;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 PyObject * obj2 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self",(char *) "offset",(char *) "whence", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 {
7545 arg2 = (int)(SWIG_As_int(obj1));
7546 if (SWIG_arg_fail(2)) SWIG_fail;
7547 }
7548 if (obj2) {
7549 {
7550 arg3 = (int)(SWIG_As_int(obj2));
7551 if (SWIG_arg_fail(3)) SWIG_fail;
7552 }
7553 }
7554 {
7555 PyThreadState* __tstate = wxPyBeginAllowThreads();
7556 (arg1)->seek(arg2,arg3);
7557
7558 wxPyEndAllowThreads(__tstate);
7559 if (PyErr_Occurred()) SWIG_fail;
7560 }
7561 Py_INCREF(Py_None); resultobj = Py_None;
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7569 PyObject *resultobj;
7570 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7571 int result;
7572 PyObject * obj0 = 0 ;
7573 char *kwnames[] = {
7574 (char *) "self", NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7579 if (SWIG_arg_fail(1)) SWIG_fail;
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (int)(arg1)->tell();
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 {
7588 resultobj = SWIG_From_int((int)(result));
7589 }
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj;
7598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7599 char result;
7600 PyObject * obj0 = 0 ;
7601 char *kwnames[] = {
7602 (char *) "self", NULL
7603 };
7604
7605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7607 if (SWIG_arg_fail(1)) SWIG_fail;
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (char)(arg1)->Peek();
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = SWIG_From_char((char)(result));
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj;
7626 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7627 char result;
7628 PyObject * obj0 = 0 ;
7629 char *kwnames[] = {
7630 (char *) "self", NULL
7631 };
7632
7633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7635 if (SWIG_arg_fail(1)) SWIG_fail;
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 result = (char)(arg1)->GetC();
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = SWIG_From_char((char)(result));
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj;
7654 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7655 size_t result;
7656 PyObject * obj0 = 0 ;
7657 char *kwnames[] = {
7658 (char *) "self", NULL
7659 };
7660
7661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7663 if (SWIG_arg_fail(1)) SWIG_fail;
7664 {
7665 PyThreadState* __tstate = wxPyBeginAllowThreads();
7666 result = (size_t)(arg1)->LastRead();
7667
7668 wxPyEndAllowThreads(__tstate);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 {
7672 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7673 }
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7683 bool result;
7684 PyObject * obj0 = 0 ;
7685 char *kwnames[] = {
7686 (char *) "self", NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7691 if (SWIG_arg_fail(1)) SWIG_fail;
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = (bool)(arg1)->CanRead();
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7701 }
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj;
7710 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7711 bool result;
7712 PyObject * obj0 = 0 ;
7713 char *kwnames[] = {
7714 (char *) "self", NULL
7715 };
7716
7717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7719 if (SWIG_arg_fail(1)) SWIG_fail;
7720 {
7721 PyThreadState* __tstate = wxPyBeginAllowThreads();
7722 result = (bool)(arg1)->Eof();
7723
7724 wxPyEndAllowThreads(__tstate);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 {
7728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7729 }
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj;
7738 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7739 char arg2 ;
7740 bool result;
7741 PyObject * obj0 = 0 ;
7742 PyObject * obj1 = 0 ;
7743 char *kwnames[] = {
7744 (char *) "self",(char *) "c", NULL
7745 };
7746
7747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7749 if (SWIG_arg_fail(1)) SWIG_fail;
7750 {
7751 arg2 = (char)(SWIG_As_char(obj1));
7752 if (SWIG_arg_fail(2)) SWIG_fail;
7753 }
7754 {
7755 PyThreadState* __tstate = wxPyBeginAllowThreads();
7756 result = (bool)(arg1)->Ungetch(arg2);
7757
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 {
7762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7763 }
7764 return resultobj;
7765 fail:
7766 return NULL;
7767 }
7768
7769
7770 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7771 PyObject *resultobj;
7772 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7773 long arg2 ;
7774 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7775 long result;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 PyObject * obj2 = 0 ;
7779 char *kwnames[] = {
7780 (char *) "self",(char *) "pos",(char *) "mode", NULL
7781 };
7782
7783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7785 if (SWIG_arg_fail(1)) SWIG_fail;
7786 {
7787 arg2 = (long)(SWIG_As_long(obj1));
7788 if (SWIG_arg_fail(2)) SWIG_fail;
7789 }
7790 if (obj2) {
7791 {
7792 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7793 if (SWIG_arg_fail(3)) SWIG_fail;
7794 }
7795 }
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7799
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 {
7804 resultobj = SWIG_From_long((long)(result));
7805 }
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7815 long result;
7816 PyObject * obj0 = 0 ;
7817 char *kwnames[] = {
7818 (char *) "self", NULL
7819 };
7820
7821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7823 if (SWIG_arg_fail(1)) SWIG_fail;
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (long)(arg1)->TellI();
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = SWIG_From_long((long)(result));
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7841 PyObject *obj;
7842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7843 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7844 Py_INCREF(obj);
7845 return Py_BuildValue((char *)"");
7846 }
7847 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7848 PyObject *resultobj;
7849 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7850 PyObject *arg2 = (PyObject *) 0 ;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 char *kwnames[] = {
7854 (char *) "self",(char *) "obj", NULL
7855 };
7856
7857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7859 if (SWIG_arg_fail(1)) SWIG_fail;
7860 arg2 = obj1;
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 wxOutputStream_write(arg1,arg2);
7864
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 Py_INCREF(Py_None); resultobj = Py_None;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7876 PyObject *obj;
7877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7878 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7879 Py_INCREF(obj);
7880 return Py_BuildValue((char *)"");
7881 }
7882 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxInputStream *arg1 = (wxInputStream *) 0 ;
7885 wxString *arg2 = 0 ;
7886 wxString *arg3 = 0 ;
7887 wxString *arg4 = 0 ;
7888 wxDateTime arg5 ;
7889 wxFSFile *result;
7890 wxPyInputStream *temp1 ;
7891 bool created1 ;
7892 bool temp2 = false ;
7893 bool temp3 = false ;
7894 bool temp4 = false ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 PyObject * obj2 = 0 ;
7898 PyObject * obj3 = 0 ;
7899 PyObject * obj4 = 0 ;
7900 char *kwnames[] = {
7901 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7902 };
7903
7904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7905 {
7906 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7907 arg1 = temp1->m_wxis;
7908 created1 = false;
7909 } else {
7910 PyErr_Clear(); // clear the failure of the wxPyConvert above
7911 arg1 = wxPyCBInputStream_create(obj0, false);
7912 if (arg1 == NULL) {
7913 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7914 SWIG_fail;
7915 }
7916 created1 = true;
7917 }
7918 }
7919 {
7920 arg2 = wxString_in_helper(obj1);
7921 if (arg2 == NULL) SWIG_fail;
7922 temp2 = true;
7923 }
7924 {
7925 arg3 = wxString_in_helper(obj2);
7926 if (arg3 == NULL) SWIG_fail;
7927 temp3 = true;
7928 }
7929 {
7930 arg4 = wxString_in_helper(obj3);
7931 if (arg4 == NULL) SWIG_fail;
7932 temp4 = true;
7933 }
7934 {
7935 wxDateTime * argp;
7936 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7937 if (SWIG_arg_fail(5)) SWIG_fail;
7938 if (argp == NULL) {
7939 SWIG_null_ref("wxDateTime");
7940 }
7941 if (SWIG_arg_fail(5)) SWIG_fail;
7942 arg5 = *argp;
7943 }
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7947
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 {
7952 resultobj = wxPyMake_wxObject(result, 1);
7953 }
7954 {
7955 if (created1)
7956 delete arg1;
7957 }
7958 {
7959 if (temp2)
7960 delete arg2;
7961 }
7962 {
7963 if (temp3)
7964 delete arg3;
7965 }
7966 {
7967 if (temp4)
7968 delete arg4;
7969 }
7970 return resultobj;
7971 fail:
7972 {
7973 if (created1)
7974 delete arg1;
7975 }
7976 {
7977 if (temp2)
7978 delete arg2;
7979 }
7980 {
7981 if (temp3)
7982 delete arg3;
7983 }
7984 {
7985 if (temp4)
7986 delete arg4;
7987 }
7988 return NULL;
7989 }
7990
7991
7992 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7993 PyObject *resultobj;
7994 wxFSFile *arg1 = (wxFSFile *) 0 ;
7995 PyObject * obj0 = 0 ;
7996 char *kwnames[] = {
7997 (char *) "self", NULL
7998 };
7999
8000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8002 if (SWIG_arg_fail(1)) SWIG_fail;
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 delete arg1;
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 Py_INCREF(Py_None); resultobj = Py_None;
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxFSFile *arg1 = (wxFSFile *) 0 ;
8020 wxInputStream *result;
8021 PyObject * obj0 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "self", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8028 if (SWIG_arg_fail(1)) SWIG_fail;
8029 {
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (wxInputStream *)(arg1)->GetStream();
8032
8033 wxPyEndAllowThreads(__tstate);
8034 if (PyErr_Occurred()) SWIG_fail;
8035 }
8036 {
8037 wxPyInputStream * _ptr = NULL;
8038
8039 if (result) {
8040 _ptr = new wxPyInputStream(result);
8041 }
8042 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8043 }
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj;
8052 wxFSFile *arg1 = (wxFSFile *) 0 ;
8053 wxString *result;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 {
8065 wxString const &_result_ref = (arg1)->GetMimeType();
8066 result = (wxString *) &_result_ref;
8067 }
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 {
8073 #if wxUSE_UNICODE
8074 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8075 #else
8076 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8077 #endif
8078 }
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj;
8087 wxFSFile *arg1 = (wxFSFile *) 0 ;
8088 wxString *result;
8089 PyObject * obj0 = 0 ;
8090 char *kwnames[] = {
8091 (char *) "self", NULL
8092 };
8093
8094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8096 if (SWIG_arg_fail(1)) SWIG_fail;
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 {
8100 wxString const &_result_ref = (arg1)->GetLocation();
8101 result = (wxString *) &_result_ref;
8102 }
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 #if wxUSE_UNICODE
8109 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8110 #else
8111 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8112 #endif
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxFSFile *arg1 = (wxFSFile *) 0 ;
8123 wxString *result;
8124 PyObject * obj0 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "self", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8131 if (SWIG_arg_fail(1)) SWIG_fail;
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 {
8135 wxString const &_result_ref = (arg1)->GetAnchor();
8136 result = (wxString *) &_result_ref;
8137 }
8138
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 {
8143 #if wxUSE_UNICODE
8144 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8145 #else
8146 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8147 #endif
8148 }
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj;
8157 wxFSFile *arg1 = (wxFSFile *) 0 ;
8158 wxDateTime result;
8159 PyObject * obj0 = 0 ;
8160 char *kwnames[] = {
8161 (char *) "self", NULL
8162 };
8163
8164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8166 if (SWIG_arg_fail(1)) SWIG_fail;
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 result = (arg1)->GetModificationTime();
8170
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 {
8175 wxDateTime * resultptr;
8176 resultptr = new wxDateTime((wxDateTime &)(result));
8177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8186 PyObject *obj;
8187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8188 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8189 Py_INCREF(obj);
8190 return Py_BuildValue((char *)"");
8191 }
8192 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8193 PyObject *obj;
8194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8195 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8196 Py_INCREF(obj);
8197 return Py_BuildValue((char *)"");
8198 }
8199 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj;
8201 wxPyFileSystemHandler *result;
8202 char *kwnames[] = {
8203 NULL
8204 };
8205
8206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8210
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj;
8223 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8224 PyObject *arg2 = (PyObject *) 0 ;
8225 PyObject *arg3 = (PyObject *) 0 ;
8226 PyObject * obj0 = 0 ;
8227 PyObject * obj1 = 0 ;
8228 PyObject * obj2 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self",(char *) "self",(char *) "_class", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 arg2 = obj1;
8237 arg3 = obj2;
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 (arg1)->_setCallbackInfo(arg2,arg3);
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 Py_INCREF(Py_None); resultobj = Py_None;
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj;
8254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8255 wxString *arg2 = 0 ;
8256 bool result;
8257 bool temp2 = false ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char *kwnames[] = {
8261 (char *) "self",(char *) "location", NULL
8262 };
8263
8264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(1)) SWIG_fail;
8267 {
8268 arg2 = wxString_in_helper(obj1);
8269 if (arg2 == NULL) SWIG_fail;
8270 temp2 = true;
8271 }
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 {
8280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8281 }
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return resultobj;
8287 fail:
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return NULL;
8293 }
8294
8295
8296 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj;
8298 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8299 wxFileSystem *arg2 = 0 ;
8300 wxString *arg3 = 0 ;
8301 wxFSFile *result;
8302 bool temp3 = false ;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 PyObject * obj2 = 0 ;
8306 char *kwnames[] = {
8307 (char *) "self",(char *) "fs",(char *) "location", NULL
8308 };
8309
8310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8312 if (SWIG_arg_fail(1)) SWIG_fail;
8313 {
8314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 if (arg2 == NULL) {
8317 SWIG_null_ref("wxFileSystem");
8318 }
8319 if (SWIG_arg_fail(2)) SWIG_fail;
8320 }
8321 {
8322 arg3 = wxString_in_helper(obj2);
8323 if (arg3 == NULL) SWIG_fail;
8324 temp3 = true;
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 {
8334 resultobj = wxPyMake_wxObject(result, 1);
8335 }
8336 {
8337 if (temp3)
8338 delete arg3;
8339 }
8340 return resultobj;
8341 fail:
8342 {
8343 if (temp3)
8344 delete arg3;
8345 }
8346 return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj;
8352 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8353 wxString *arg2 = 0 ;
8354 int arg3 = (int) 0 ;
8355 wxString result;
8356 bool temp2 = false ;
8357 PyObject * obj0 = 0 ;
8358 PyObject * obj1 = 0 ;
8359 PyObject * obj2 = 0 ;
8360 char *kwnames[] = {
8361 (char *) "self",(char *) "spec",(char *) "flags", NULL
8362 };
8363
8364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8366 if (SWIG_arg_fail(1)) SWIG_fail;
8367 {
8368 arg2 = wxString_in_helper(obj1);
8369 if (arg2 == NULL) SWIG_fail;
8370 temp2 = true;
8371 }
8372 if (obj2) {
8373 {
8374 arg3 = (int)(SWIG_As_int(obj2));
8375 if (SWIG_arg_fail(3)) SWIG_fail;
8376 }
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 {
8386 #if wxUSE_UNICODE
8387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8388 #else
8389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8390 #endif
8391 }
8392 {
8393 if (temp2)
8394 delete arg2;
8395 }
8396 return resultobj;
8397 fail:
8398 {
8399 if (temp2)
8400 delete arg2;
8401 }
8402 return NULL;
8403 }
8404
8405
8406 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8407 PyObject *resultobj;
8408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8409 wxString result;
8410 PyObject * obj0 = 0 ;
8411 char *kwnames[] = {
8412 (char *) "self", NULL
8413 };
8414
8415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8417 if (SWIG_arg_fail(1)) SWIG_fail;
8418 {
8419 PyThreadState* __tstate = wxPyBeginAllowThreads();
8420 result = (arg1)->FindNext();
8421
8422 wxPyEndAllowThreads(__tstate);
8423 if (PyErr_Occurred()) SWIG_fail;
8424 }
8425 {
8426 #if wxUSE_UNICODE
8427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8428 #else
8429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8430 #endif
8431 }
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj;
8440 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8441 wxString *arg2 = 0 ;
8442 wxString result;
8443 bool temp2 = false ;
8444 PyObject * obj0 = 0 ;
8445 PyObject * obj1 = 0 ;
8446 char *kwnames[] = {
8447 (char *) "self",(char *) "location", NULL
8448 };
8449
8450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8452 if (SWIG_arg_fail(1)) SWIG_fail;
8453 {
8454 arg2 = wxString_in_helper(obj1);
8455 if (arg2 == NULL) SWIG_fail;
8456 temp2 = true;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (arg1)->GetProtocol((wxString const &)*arg2);
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 {
8466 #if wxUSE_UNICODE
8467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8468 #else
8469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8470 #endif
8471 }
8472 {
8473 if (temp2)
8474 delete arg2;
8475 }
8476 return resultobj;
8477 fail:
8478 {
8479 if (temp2)
8480 delete arg2;
8481 }
8482 return NULL;
8483 }
8484
8485
8486 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8487 PyObject *resultobj;
8488 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8489 wxString *arg2 = 0 ;
8490 wxString result;
8491 bool temp2 = false ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char *kwnames[] = {
8495 (char *) "self",(char *) "location", NULL
8496 };
8497
8498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8500 if (SWIG_arg_fail(1)) SWIG_fail;
8501 {
8502 arg2 = wxString_in_helper(obj1);
8503 if (arg2 == NULL) SWIG_fail;
8504 temp2 = true;
8505 }
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8509
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 {
8514 #if wxUSE_UNICODE
8515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8516 #else
8517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8518 #endif
8519 }
8520 {
8521 if (temp2)
8522 delete arg2;
8523 }
8524 return resultobj;
8525 fail:
8526 {
8527 if (temp2)
8528 delete arg2;
8529 }
8530 return NULL;
8531 }
8532
8533
8534 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj;
8536 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8537 wxString *arg2 = 0 ;
8538 wxString result;
8539 bool temp2 = false ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "self",(char *) "location", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 {
8550 arg2 = wxString_in_helper(obj1);
8551 if (arg2 == NULL) SWIG_fail;
8552 temp2 = true;
8553 }
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 result = (arg1)->GetAnchor((wxString const &)*arg2);
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 #if wxUSE_UNICODE
8563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8564 #else
8565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8566 #endif
8567 }
8568 {
8569 if (temp2)
8570 delete arg2;
8571 }
8572 return resultobj;
8573 fail:
8574 {
8575 if (temp2)
8576 delete arg2;
8577 }
8578 return NULL;
8579 }
8580
8581
8582 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj;
8584 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8585 wxString *arg2 = 0 ;
8586 wxString result;
8587 bool temp2 = false ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char *kwnames[] = {
8591 (char *) "self",(char *) "location", NULL
8592 };
8593
8594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 {
8598 arg2 = wxString_in_helper(obj1);
8599 if (arg2 == NULL) SWIG_fail;
8600 temp2 = true;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8605
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 {
8610 #if wxUSE_UNICODE
8611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8612 #else
8613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8614 #endif
8615 }
8616 {
8617 if (temp2)
8618 delete arg2;
8619 }
8620 return resultobj;
8621 fail:
8622 {
8623 if (temp2)
8624 delete arg2;
8625 }
8626 return NULL;
8627 }
8628
8629
8630 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8631 PyObject *resultobj;
8632 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8633 wxString *arg2 = 0 ;
8634 wxString result;
8635 bool temp2 = false ;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 char *kwnames[] = {
8639 (char *) "self",(char *) "location", NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8644 if (SWIG_arg_fail(1)) SWIG_fail;
8645 {
8646 arg2 = wxString_in_helper(obj1);
8647 if (arg2 == NULL) SWIG_fail;
8648 temp2 = true;
8649 }
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 {
8658 #if wxUSE_UNICODE
8659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8660 #else
8661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8662 #endif
8663 }
8664 {
8665 if (temp2)
8666 delete arg2;
8667 }
8668 return resultobj;
8669 fail:
8670 {
8671 if (temp2)
8672 delete arg2;
8673 }
8674 return NULL;
8675 }
8676
8677
8678 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8679 PyObject *obj;
8680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8681 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8682 Py_INCREF(obj);
8683 return Py_BuildValue((char *)"");
8684 }
8685 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj;
8687 wxFileSystem *result;
8688 char *kwnames[] = {
8689 NULL
8690 };
8691
8692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (wxFileSystem *)new wxFileSystem();
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 resultobj = wxPyMake_wxObject(result, 1);
8702 }
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj;
8711 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8712 PyObject * obj0 = 0 ;
8713 char *kwnames[] = {
8714 (char *) "self", NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 delete arg1;
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 Py_INCREF(Py_None); resultobj = Py_None;
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8737 wxString *arg2 = 0 ;
8738 bool arg3 = (bool) false ;
8739 bool temp2 = false ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 PyObject * obj2 = 0 ;
8743 char *kwnames[] = {
8744 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8745 };
8746
8747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8749 if (SWIG_arg_fail(1)) SWIG_fail;
8750 {
8751 arg2 = wxString_in_helper(obj1);
8752 if (arg2 == NULL) SWIG_fail;
8753 temp2 = true;
8754 }
8755 if (obj2) {
8756 {
8757 arg3 = (bool)(SWIG_As_bool(obj2));
8758 if (SWIG_arg_fail(3)) SWIG_fail;
8759 }
8760 }
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 {
8770 if (temp2)
8771 delete arg2;
8772 }
8773 return resultobj;
8774 fail:
8775 {
8776 if (temp2)
8777 delete arg2;
8778 }
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8786 wxString result;
8787 PyObject * obj0 = 0 ;
8788 char *kwnames[] = {
8789 (char *) "self", NULL
8790 };
8791
8792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8794 if (SWIG_arg_fail(1)) SWIG_fail;
8795 {
8796 PyThreadState* __tstate = wxPyBeginAllowThreads();
8797 result = (arg1)->GetPath();
8798
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 {
8803 #if wxUSE_UNICODE
8804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8805 #else
8806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8807 #endif
8808 }
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj;
8817 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8818 wxString *arg2 = 0 ;
8819 wxFSFile *result;
8820 bool temp2 = false ;
8821 PyObject * obj0 = 0 ;
8822 PyObject * obj1 = 0 ;
8823 char *kwnames[] = {
8824 (char *) "self",(char *) "location", NULL
8825 };
8826
8827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8829 if (SWIG_arg_fail(1)) SWIG_fail;
8830 {
8831 arg2 = wxString_in_helper(obj1);
8832 if (arg2 == NULL) SWIG_fail;
8833 temp2 = true;
8834 }
8835 {
8836 PyThreadState* __tstate = wxPyBeginAllowThreads();
8837 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8838
8839 wxPyEndAllowThreads(__tstate);
8840 if (PyErr_Occurred()) SWIG_fail;
8841 }
8842 {
8843 resultobj = wxPyMake_wxObject(result, 1);
8844 }
8845 {
8846 if (temp2)
8847 delete arg2;
8848 }
8849 return resultobj;
8850 fail:
8851 {
8852 if (temp2)
8853 delete arg2;
8854 }
8855 return NULL;
8856 }
8857
8858
8859 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj;
8861 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8862 wxString *arg2 = 0 ;
8863 int arg3 = (int) 0 ;
8864 wxString result;
8865 bool temp2 = false ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "self",(char *) "spec",(char *) "flags", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 {
8877 arg2 = wxString_in_helper(obj1);
8878 if (arg2 == NULL) SWIG_fail;
8879 temp2 = true;
8880 }
8881 if (obj2) {
8882 {
8883 arg3 = (int)(SWIG_As_int(obj2));
8884 if (SWIG_arg_fail(3)) SWIG_fail;
8885 }
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 {
8895 #if wxUSE_UNICODE
8896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8897 #else
8898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8899 #endif
8900 }
8901 {
8902 if (temp2)
8903 delete arg2;
8904 }
8905 return resultobj;
8906 fail:
8907 {
8908 if (temp2)
8909 delete arg2;
8910 }
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8918 wxString result;
8919 PyObject * obj0 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "self", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 result = (arg1)->FindNext();
8930
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 {
8935 #if wxUSE_UNICODE
8936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8937 #else
8938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8939 #endif
8940 }
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj;
8949 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8950 PyObject * obj0 = 0 ;
8951 char *kwnames[] = {
8952 (char *) "handler", NULL
8953 };
8954
8955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8957 if (SWIG_arg_fail(1)) SWIG_fail;
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 wxFileSystem::AddHandler(arg1);
8961
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 Py_INCREF(Py_None); resultobj = Py_None;
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 char *kwnames[] = {
8975 NULL
8976 };
8977
8978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 wxFileSystem::CleanUpHandlers();
8982
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 Py_INCREF(Py_None); resultobj = Py_None;
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj;
8995 wxString *arg1 = 0 ;
8996 wxString result;
8997 bool temp1 = false ;
8998 PyObject * obj0 = 0 ;
8999 char *kwnames[] = {
9000 (char *) "filename", NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9004 {
9005 arg1 = wxString_in_helper(obj0);
9006 if (arg1 == NULL) SWIG_fail;
9007 temp1 = true;
9008 }
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 {
9017 #if wxUSE_UNICODE
9018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9019 #else
9020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9021 #endif
9022 }
9023 {
9024 if (temp1)
9025 delete arg1;
9026 }
9027 return resultobj;
9028 fail:
9029 {
9030 if (temp1)
9031 delete arg1;
9032 }
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 wxString *arg1 = 0 ;
9040 wxString result;
9041 bool temp1 = false ;
9042 PyObject * obj0 = 0 ;
9043 char *kwnames[] = {
9044 (char *) "url", NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9048 {
9049 arg1 = wxString_in_helper(obj0);
9050 if (arg1 == NULL) SWIG_fail;
9051 temp1 = true;
9052 }
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = FileSystem_URLToFileName((wxString const &)*arg1);
9056
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 {
9061 #if wxUSE_UNICODE
9062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9063 #else
9064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9065 #endif
9066 }
9067 {
9068 if (temp1)
9069 delete arg1;
9070 }
9071 return resultobj;
9072 fail:
9073 {
9074 if (temp1)
9075 delete arg1;
9076 }
9077 return NULL;
9078 }
9079
9080
9081 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9082 PyObject *obj;
9083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9084 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9085 Py_INCREF(obj);
9086 return Py_BuildValue((char *)"");
9087 }
9088 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 wxInternetFSHandler *result;
9091 char *kwnames[] = {
9092 NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9113 wxString *arg2 = 0 ;
9114 bool result;
9115 bool temp2 = false ;
9116 PyObject * obj0 = 0 ;
9117 PyObject * obj1 = 0 ;
9118 char *kwnames[] = {
9119 (char *) "self",(char *) "location", NULL
9120 };
9121
9122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9124 if (SWIG_arg_fail(1)) SWIG_fail;
9125 {
9126 arg2 = wxString_in_helper(obj1);
9127 if (arg2 == NULL) SWIG_fail;
9128 temp2 = true;
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9133
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 {
9138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9139 }
9140 {
9141 if (temp2)
9142 delete arg2;
9143 }
9144 return resultobj;
9145 fail:
9146 {
9147 if (temp2)
9148 delete arg2;
9149 }
9150 return NULL;
9151 }
9152
9153
9154 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9155 PyObject *resultobj;
9156 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9157 wxFileSystem *arg2 = 0 ;
9158 wxString *arg3 = 0 ;
9159 wxFSFile *result;
9160 bool temp3 = false ;
9161 PyObject * obj0 = 0 ;
9162 PyObject * obj1 = 0 ;
9163 PyObject * obj2 = 0 ;
9164 char *kwnames[] = {
9165 (char *) "self",(char *) "fs",(char *) "location", NULL
9166 };
9167
9168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9170 if (SWIG_arg_fail(1)) SWIG_fail;
9171 {
9172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9173 if (SWIG_arg_fail(2)) SWIG_fail;
9174 if (arg2 == NULL) {
9175 SWIG_null_ref("wxFileSystem");
9176 }
9177 if (SWIG_arg_fail(2)) SWIG_fail;
9178 }
9179 {
9180 arg3 = wxString_in_helper(obj2);
9181 if (arg3 == NULL) SWIG_fail;
9182 temp3 = true;
9183 }
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9187
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 {
9192 resultobj = wxPyMake_wxObject(result, 1);
9193 }
9194 {
9195 if (temp3)
9196 delete arg3;
9197 }
9198 return resultobj;
9199 fail:
9200 {
9201 if (temp3)
9202 delete arg3;
9203 }
9204 return NULL;
9205 }
9206
9207
9208 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9209 PyObject *obj;
9210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9211 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9212 Py_INCREF(obj);
9213 return Py_BuildValue((char *)"");
9214 }
9215 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj;
9217 wxZipFSHandler *result;
9218 char *kwnames[] = {
9219 NULL
9220 };
9221
9222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9223 {
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (wxZipFSHandler *)new wxZipFSHandler();
9226
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9238 PyObject *resultobj;
9239 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9240 wxString *arg2 = 0 ;
9241 bool result;
9242 bool temp2 = false ;
9243 PyObject * obj0 = 0 ;
9244 PyObject * obj1 = 0 ;
9245 char *kwnames[] = {
9246 (char *) "self",(char *) "location", NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9251 if (SWIG_arg_fail(1)) SWIG_fail;
9252 {
9253 arg2 = wxString_in_helper(obj1);
9254 if (arg2 == NULL) SWIG_fail;
9255 temp2 = true;
9256 }
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9266 }
9267 {
9268 if (temp2)
9269 delete arg2;
9270 }
9271 return resultobj;
9272 fail:
9273 {
9274 if (temp2)
9275 delete arg2;
9276 }
9277 return NULL;
9278 }
9279
9280
9281 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9282 PyObject *resultobj;
9283 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9284 wxFileSystem *arg2 = 0 ;
9285 wxString *arg3 = 0 ;
9286 wxFSFile *result;
9287 bool temp3 = false ;
9288 PyObject * obj0 = 0 ;
9289 PyObject * obj1 = 0 ;
9290 PyObject * obj2 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self",(char *) "fs",(char *) "location", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9300 if (SWIG_arg_fail(2)) SWIG_fail;
9301 if (arg2 == NULL) {
9302 SWIG_null_ref("wxFileSystem");
9303 }
9304 if (SWIG_arg_fail(2)) SWIG_fail;
9305 }
9306 {
9307 arg3 = wxString_in_helper(obj2);
9308 if (arg3 == NULL) SWIG_fail;
9309 temp3 = true;
9310 }
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 {
9319 resultobj = wxPyMake_wxObject(result, 1);
9320 }
9321 {
9322 if (temp3)
9323 delete arg3;
9324 }
9325 return resultobj;
9326 fail:
9327 {
9328 if (temp3)
9329 delete arg3;
9330 }
9331 return NULL;
9332 }
9333
9334
9335 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj;
9337 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9338 wxString *arg2 = 0 ;
9339 int arg3 = (int) 0 ;
9340 wxString result;
9341 bool temp2 = false ;
9342 PyObject * obj0 = 0 ;
9343 PyObject * obj1 = 0 ;
9344 PyObject * obj2 = 0 ;
9345 char *kwnames[] = {
9346 (char *) "self",(char *) "spec",(char *) "flags", NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9351 if (SWIG_arg_fail(1)) SWIG_fail;
9352 {
9353 arg2 = wxString_in_helper(obj1);
9354 if (arg2 == NULL) SWIG_fail;
9355 temp2 = true;
9356 }
9357 if (obj2) {
9358 {
9359 arg3 = (int)(SWIG_As_int(obj2));
9360 if (SWIG_arg_fail(3)) SWIG_fail;
9361 }
9362 }
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 #if wxUSE_UNICODE
9372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9373 #else
9374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9375 #endif
9376 }
9377 {
9378 if (temp2)
9379 delete arg2;
9380 }
9381 return resultobj;
9382 fail:
9383 {
9384 if (temp2)
9385 delete arg2;
9386 }
9387 return NULL;
9388 }
9389
9390
9391 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9392 PyObject *resultobj;
9393 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9394 wxString result;
9395 PyObject * obj0 = 0 ;
9396 char *kwnames[] = {
9397 (char *) "self", NULL
9398 };
9399
9400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9402 if (SWIG_arg_fail(1)) SWIG_fail;
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (arg1)->FindNext();
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 #if wxUSE_UNICODE
9412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9413 #else
9414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9415 #endif
9416 }
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9424 PyObject *obj;
9425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9426 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9427 Py_INCREF(obj);
9428 return Py_BuildValue((char *)"");
9429 }
9430 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj;
9432 wxString *arg1 = 0 ;
9433 wxImage *arg2 = 0 ;
9434 long arg3 ;
9435 bool temp1 = false ;
9436 PyObject * obj0 = 0 ;
9437 PyObject * obj1 = 0 ;
9438 PyObject * obj2 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "filename",(char *) "image",(char *) "type", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9444 {
9445 arg1 = wxString_in_helper(obj0);
9446 if (arg1 == NULL) SWIG_fail;
9447 temp1 = true;
9448 }
9449 {
9450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 if (arg2 == NULL) {
9453 SWIG_null_ref("wxImage");
9454 }
9455 if (SWIG_arg_fail(2)) SWIG_fail;
9456 }
9457 {
9458 arg3 = (long)(SWIG_As_long(obj2));
9459 if (SWIG_arg_fail(3)) SWIG_fail;
9460 }
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9464
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 Py_INCREF(Py_None); resultobj = Py_None;
9469 {
9470 if (temp1)
9471 delete arg1;
9472 }
9473 return resultobj;
9474 fail:
9475 {
9476 if (temp1)
9477 delete arg1;
9478 }
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj;
9485 wxString *arg1 = 0 ;
9486 wxBitmap *arg2 = 0 ;
9487 long arg3 ;
9488 bool temp1 = false ;
9489 PyObject * obj0 = 0 ;
9490 PyObject * obj1 = 0 ;
9491 PyObject * obj2 = 0 ;
9492 char *kwnames[] = {
9493 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9494 };
9495
9496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9497 {
9498 arg1 = wxString_in_helper(obj0);
9499 if (arg1 == NULL) SWIG_fail;
9500 temp1 = true;
9501 }
9502 {
9503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 if (arg2 == NULL) {
9506 SWIG_null_ref("wxBitmap");
9507 }
9508 if (SWIG_arg_fail(2)) SWIG_fail;
9509 }
9510 {
9511 arg3 = (long)(SWIG_As_long(obj2));
9512 if (SWIG_arg_fail(3)) SWIG_fail;
9513 }
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 Py_INCREF(Py_None); resultobj = Py_None;
9522 {
9523 if (temp1)
9524 delete arg1;
9525 }
9526 return resultobj;
9527 fail:
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return NULL;
9533 }
9534
9535
9536 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9537 PyObject *resultobj;
9538 wxString *arg1 = 0 ;
9539 PyObject *arg2 = (PyObject *) 0 ;
9540 bool temp1 = false ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 char *kwnames[] = {
9544 (char *) "filename",(char *) "data", NULL
9545 };
9546
9547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9548 {
9549 arg1 = wxString_in_helper(obj0);
9550 if (arg1 == NULL) SWIG_fail;
9551 temp1 = true;
9552 }
9553 arg2 = obj1;
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9557
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 Py_INCREF(Py_None); resultobj = Py_None;
9562 {
9563 if (temp1)
9564 delete arg1;
9565 }
9566 return resultobj;
9567 fail:
9568 {
9569 if (temp1)
9570 delete arg1;
9571 }
9572 return NULL;
9573 }
9574
9575
9576 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9577 PyObject *resultobj;
9578 wxMemoryFSHandler *result;
9579 char *kwnames[] = {
9580 NULL
9581 };
9582
9583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9584 {
9585 PyThreadState* __tstate = wxPyBeginAllowThreads();
9586 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9587
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxString *arg1 = 0 ;
9601 bool temp1 = false ;
9602 PyObject * obj0 = 0 ;
9603 char *kwnames[] = {
9604 (char *) "filename", NULL
9605 };
9606
9607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9608 {
9609 arg1 = wxString_in_helper(obj0);
9610 if (arg1 == NULL) SWIG_fail;
9611 temp1 = true;
9612 }
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9638 wxString *arg2 = 0 ;
9639 bool result;
9640 bool temp2 = false ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char *kwnames[] = {
9644 (char *) "self",(char *) "location", NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(1)) SWIG_fail;
9650 {
9651 arg2 = wxString_in_helper(obj1);
9652 if (arg2 == NULL) SWIG_fail;
9653 temp2 = true;
9654 }
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 {
9663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9664 }
9665 {
9666 if (temp2)
9667 delete arg2;
9668 }
9669 return resultobj;
9670 fail:
9671 {
9672 if (temp2)
9673 delete arg2;
9674 }
9675 return NULL;
9676 }
9677
9678
9679 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj;
9681 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9682 wxFileSystem *arg2 = 0 ;
9683 wxString *arg3 = 0 ;
9684 wxFSFile *result;
9685 bool temp3 = false ;
9686 PyObject * obj0 = 0 ;
9687 PyObject * obj1 = 0 ;
9688 PyObject * obj2 = 0 ;
9689 char *kwnames[] = {
9690 (char *) "self",(char *) "fs",(char *) "location", NULL
9691 };
9692
9693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9695 if (SWIG_arg_fail(1)) SWIG_fail;
9696 {
9697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(2)) SWIG_fail;
9699 if (arg2 == NULL) {
9700 SWIG_null_ref("wxFileSystem");
9701 }
9702 if (SWIG_arg_fail(2)) SWIG_fail;
9703 }
9704 {
9705 arg3 = wxString_in_helper(obj2);
9706 if (arg3 == NULL) SWIG_fail;
9707 temp3 = true;
9708 }
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9712
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 {
9717 resultobj = wxPyMake_wxObject(result, 1);
9718 }
9719 {
9720 if (temp3)
9721 delete arg3;
9722 }
9723 return resultobj;
9724 fail:
9725 {
9726 if (temp3)
9727 delete arg3;
9728 }
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj;
9735 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9736 wxString *arg2 = 0 ;
9737 int arg3 = (int) 0 ;
9738 wxString result;
9739 bool temp2 = false ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 PyObject * obj2 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self",(char *) "spec",(char *) "flags", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 {
9751 arg2 = wxString_in_helper(obj1);
9752 if (arg2 == NULL) SWIG_fail;
9753 temp2 = true;
9754 }
9755 if (obj2) {
9756 {
9757 arg3 = (int)(SWIG_As_int(obj2));
9758 if (SWIG_arg_fail(3)) SWIG_fail;
9759 }
9760 }
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 {
9769 #if wxUSE_UNICODE
9770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9771 #else
9772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9773 #endif
9774 }
9775 {
9776 if (temp2)
9777 delete arg2;
9778 }
9779 return resultobj;
9780 fail:
9781 {
9782 if (temp2)
9783 delete arg2;
9784 }
9785 return NULL;
9786 }
9787
9788
9789 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj;
9791 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9792 wxString result;
9793 PyObject * obj0 = 0 ;
9794 char *kwnames[] = {
9795 (char *) "self", NULL
9796 };
9797
9798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9800 if (SWIG_arg_fail(1)) SWIG_fail;
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 result = (arg1)->FindNext();
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 #if wxUSE_UNICODE
9810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9811 #else
9812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9813 #endif
9814 }
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9822 PyObject *obj;
9823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9824 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9825 Py_INCREF(obj);
9826 return Py_BuildValue((char *)"");
9827 }
9828 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj;
9830 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9831 wxString result;
9832 PyObject * obj0 = 0 ;
9833 char *kwnames[] = {
9834 (char *) "self", NULL
9835 };
9836
9837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9839 if (SWIG_arg_fail(1)) SWIG_fail;
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 result = (arg1)->GetName();
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 {
9848 #if wxUSE_UNICODE
9849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9850 #else
9851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9852 #endif
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj;
9862 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9863 wxString result;
9864 PyObject * obj0 = 0 ;
9865 char *kwnames[] = {
9866 (char *) "self", NULL
9867 };
9868
9869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9871 if (SWIG_arg_fail(1)) SWIG_fail;
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 result = (arg1)->GetExtension();
9875
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 {
9880 #if wxUSE_UNICODE
9881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9882 #else
9883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9884 #endif
9885 }
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj;
9894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9895 long result;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (long)(arg1)->GetType();
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 {
9912 resultobj = SWIG_From_long((long)(result));
9913 }
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9921 PyObject *resultobj;
9922 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9923 wxString result;
9924 PyObject * obj0 = 0 ;
9925 char *kwnames[] = {
9926 (char *) "self", NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(1)) SWIG_fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (arg1)->GetMimeType();
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 {
9940 #if wxUSE_UNICODE
9941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9942 #else
9943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9944 #endif
9945 }
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj;
9954 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9955 wxString *arg2 = 0 ;
9956 bool result;
9957 bool temp2 = false ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960 char *kwnames[] = {
9961 (char *) "self",(char *) "name", NULL
9962 };
9963
9964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9966 if (SWIG_arg_fail(1)) SWIG_fail;
9967 {
9968 arg2 = wxString_in_helper(obj1);
9969 if (arg2 == NULL) SWIG_fail;
9970 temp2 = true;
9971 }
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9975
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 {
9980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9981 }
9982 {
9983 if (temp2)
9984 delete arg2;
9985 }
9986 return resultobj;
9987 fail:
9988 {
9989 if (temp2)
9990 delete arg2;
9991 }
9992 return NULL;
9993 }
9994
9995
9996 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj;
9998 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9999 wxString *arg2 = 0 ;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "self",(char *) "name", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10009 if (SWIG_arg_fail(1)) SWIG_fail;
10010 {
10011 arg2 = wxString_in_helper(obj1);
10012 if (arg2 == NULL) SWIG_fail;
10013 temp2 = true;
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 (arg1)->SetName((wxString const &)*arg2);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 Py_INCREF(Py_None); resultobj = Py_None;
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 return resultobj;
10028 fail:
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return NULL;
10034 }
10035
10036
10037 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10040 wxString *arg2 = 0 ;
10041 bool temp2 = false ;
10042 PyObject * obj0 = 0 ;
10043 PyObject * obj1 = 0 ;
10044 char *kwnames[] = {
10045 (char *) "self",(char *) "extension", NULL
10046 };
10047
10048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10050 if (SWIG_arg_fail(1)) SWIG_fail;
10051 {
10052 arg2 = wxString_in_helper(obj1);
10053 if (arg2 == NULL) SWIG_fail;
10054 temp2 = true;
10055 }
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 (arg1)->SetExtension((wxString const &)*arg2);
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 Py_INCREF(Py_None); resultobj = Py_None;
10064 {
10065 if (temp2)
10066 delete arg2;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp2)
10072 delete arg2;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj;
10080 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10081 long arg2 ;
10082 PyObject * obj0 = 0 ;
10083 PyObject * obj1 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "self",(char *) "type", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10090 if (SWIG_arg_fail(1)) SWIG_fail;
10091 {
10092 arg2 = (long)(SWIG_As_long(obj1));
10093 if (SWIG_arg_fail(2)) SWIG_fail;
10094 }
10095 {
10096 PyThreadState* __tstate = wxPyBeginAllowThreads();
10097 (arg1)->SetType(arg2);
10098
10099 wxPyEndAllowThreads(__tstate);
10100 if (PyErr_Occurred()) SWIG_fail;
10101 }
10102 Py_INCREF(Py_None); resultobj = Py_None;
10103 return resultobj;
10104 fail:
10105 return NULL;
10106 }
10107
10108
10109 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10110 PyObject *resultobj;
10111 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10112 wxString *arg2 = 0 ;
10113 bool temp2 = false ;
10114 PyObject * obj0 = 0 ;
10115 PyObject * obj1 = 0 ;
10116 char *kwnames[] = {
10117 (char *) "self",(char *) "mimetype", NULL
10118 };
10119
10120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10122 if (SWIG_arg_fail(1)) SWIG_fail;
10123 {
10124 arg2 = wxString_in_helper(obj1);
10125 if (arg2 == NULL) SWIG_fail;
10126 temp2 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 (arg1)->SetMimeType((wxString const &)*arg2);
10131
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 Py_INCREF(Py_None); resultobj = Py_None;
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10151 PyObject *obj;
10152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10153 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10154 Py_INCREF(obj);
10155 return Py_BuildValue((char *)"");
10156 }
10157 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10158 PyObject *resultobj;
10159 wxImageHistogram *result;
10160 char *kwnames[] = {
10161 NULL
10162 };
10163
10164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 result = (wxImageHistogram *)new wxImageHistogram();
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 unsigned char arg1 ;
10182 unsigned char arg2 ;
10183 unsigned char arg3 ;
10184 unsigned long result;
10185 PyObject * obj0 = 0 ;
10186 PyObject * obj1 = 0 ;
10187 PyObject * obj2 = 0 ;
10188 char *kwnames[] = {
10189 (char *) "r",(char *) "g",(char *) "b", NULL
10190 };
10191
10192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10193 {
10194 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10195 if (SWIG_arg_fail(1)) SWIG_fail;
10196 }
10197 {
10198 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10199 if (SWIG_arg_fail(2)) SWIG_fail;
10200 }
10201 {
10202 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10203 if (SWIG_arg_fail(3)) SWIG_fail;
10204 }
10205 {
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10208
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 {
10213 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10214 }
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj;
10223 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10224 unsigned char *arg2 = (unsigned char *) 0 ;
10225 unsigned char *arg3 = (unsigned char *) 0 ;
10226 unsigned char *arg4 = (unsigned char *) 0 ;
10227 unsigned char arg5 = (unsigned char) 1 ;
10228 unsigned char arg6 = (unsigned char) 0 ;
10229 unsigned char arg7 = (unsigned char) 0 ;
10230 bool result;
10231 unsigned char temp2 ;
10232 int res2 = 0 ;
10233 unsigned char temp3 ;
10234 int res3 = 0 ;
10235 unsigned char temp4 ;
10236 int res4 = 0 ;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 PyObject * obj2 = 0 ;
10240 PyObject * obj3 = 0 ;
10241 char *kwnames[] = {
10242 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10243 };
10244
10245 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10247 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10250 if (SWIG_arg_fail(1)) SWIG_fail;
10251 if (obj1) {
10252 {
10253 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10254 if (SWIG_arg_fail(5)) SWIG_fail;
10255 }
10256 }
10257 if (obj2) {
10258 {
10259 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10260 if (SWIG_arg_fail(6)) SWIG_fail;
10261 }
10262 }
10263 if (obj3) {
10264 {
10265 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10266 if (SWIG_arg_fail(7)) SWIG_fail;
10267 }
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10278 }
10279 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10281 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10282 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10283 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10284 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10292 PyObject *obj;
10293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10294 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10295 Py_INCREF(obj);
10296 return Py_BuildValue((char *)"");
10297 }
10298 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj;
10300 wxString *arg1 = 0 ;
10301 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10302 int arg3 = (int) -1 ;
10303 wxImage *result;
10304 bool temp1 = false ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 PyObject * obj2 = 0 ;
10308 char *kwnames[] = {
10309 (char *) "name",(char *) "type",(char *) "index", NULL
10310 };
10311
10312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10313 {
10314 arg1 = wxString_in_helper(obj0);
10315 if (arg1 == NULL) SWIG_fail;
10316 temp1 = true;
10317 }
10318 if (obj1) {
10319 {
10320 arg2 = (long)(SWIG_As_long(obj1));
10321 if (SWIG_arg_fail(2)) SWIG_fail;
10322 }
10323 }
10324 if (obj2) {
10325 {
10326 arg3 = (int)(SWIG_As_int(obj2));
10327 if (SWIG_arg_fail(3)) SWIG_fail;
10328 }
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10333
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10338 {
10339 if (temp1)
10340 delete arg1;
10341 }
10342 return resultobj;
10343 fail:
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return NULL;
10349 }
10350
10351
10352 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj;
10354 wxImage *arg1 = (wxImage *) 0 ;
10355 PyObject * obj0 = 0 ;
10356 char *kwnames[] = {
10357 (char *) "self", NULL
10358 };
10359
10360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10362 if (SWIG_arg_fail(1)) SWIG_fail;
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 delete arg1;
10366
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 Py_INCREF(Py_None); resultobj = Py_None;
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxString *arg1 = 0 ;
10380 wxString *arg2 = 0 ;
10381 int arg3 = (int) -1 ;
10382 wxImage *result;
10383 bool temp1 = false ;
10384 bool temp2 = false ;
10385 PyObject * obj0 = 0 ;
10386 PyObject * obj1 = 0 ;
10387 PyObject * obj2 = 0 ;
10388 char *kwnames[] = {
10389 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10390 };
10391
10392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10393 {
10394 arg1 = wxString_in_helper(obj0);
10395 if (arg1 == NULL) SWIG_fail;
10396 temp1 = true;
10397 }
10398 {
10399 arg2 = wxString_in_helper(obj1);
10400 if (arg2 == NULL) SWIG_fail;
10401 temp2 = true;
10402 }
10403 if (obj2) {
10404 {
10405 arg3 = (int)(SWIG_As_int(obj2));
10406 if (SWIG_arg_fail(3)) SWIG_fail;
10407 }
10408 }
10409 {
10410 PyThreadState* __tstate = wxPyBeginAllowThreads();
10411 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10412
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10417 {
10418 if (temp1)
10419 delete arg1;
10420 }
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return resultobj;
10426 fail:
10427 {
10428 if (temp1)
10429 delete arg1;
10430 }
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj;
10441 wxInputStream *arg1 = 0 ;
10442 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10443 int arg3 = (int) -1 ;
10444 wxImage *result;
10445 wxPyInputStream *temp1 ;
10446 bool created1 ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 PyObject * obj2 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "stream",(char *) "type",(char *) "index", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10455 {
10456 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10457 arg1 = temp1->m_wxis;
10458 created1 = false;
10459 } else {
10460 PyErr_Clear(); // clear the failure of the wxPyConvert above
10461 arg1 = wxPyCBInputStream_create(obj0, false);
10462 if (arg1 == NULL) {
10463 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10464 SWIG_fail;
10465 }
10466 created1 = true;
10467 }
10468 }
10469 if (obj1) {
10470 {
10471 arg2 = (long)(SWIG_As_long(obj1));
10472 if (SWIG_arg_fail(2)) SWIG_fail;
10473 }
10474 }
10475 if (obj2) {
10476 {
10477 arg3 = (int)(SWIG_As_int(obj2));
10478 if (SWIG_arg_fail(3)) SWIG_fail;
10479 }
10480 }
10481 {
10482 PyThreadState* __tstate = wxPyBeginAllowThreads();
10483 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10484
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10489 {
10490 if (created1)
10491 delete arg1;
10492 }
10493 return resultobj;
10494 fail:
10495 {
10496 if (created1)
10497 delete arg1;
10498 }
10499 return NULL;
10500 }
10501
10502
10503 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10504 PyObject *resultobj;
10505 wxInputStream *arg1 = 0 ;
10506 wxString *arg2 = 0 ;
10507 int arg3 = (int) -1 ;
10508 wxImage *result;
10509 wxPyInputStream *temp1 ;
10510 bool created1 ;
10511 bool temp2 = false ;
10512 PyObject * obj0 = 0 ;
10513 PyObject * obj1 = 0 ;
10514 PyObject * obj2 = 0 ;
10515 char *kwnames[] = {
10516 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10517 };
10518
10519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10520 {
10521 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10522 arg1 = temp1->m_wxis;
10523 created1 = false;
10524 } else {
10525 PyErr_Clear(); // clear the failure of the wxPyConvert above
10526 arg1 = wxPyCBInputStream_create(obj0, false);
10527 if (arg1 == NULL) {
10528 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10529 SWIG_fail;
10530 }
10531 created1 = true;
10532 }
10533 }
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 if (obj2) {
10540 {
10541 arg3 = (int)(SWIG_As_int(obj2));
10542 if (SWIG_arg_fail(3)) SWIG_fail;
10543 }
10544 }
10545 {
10546 PyThreadState* __tstate = wxPyBeginAllowThreads();
10547 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10548
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10553 {
10554 if (created1)
10555 delete arg1;
10556 }
10557 {
10558 if (temp2)
10559 delete arg2;
10560 }
10561 return resultobj;
10562 fail:
10563 {
10564 if (created1)
10565 delete arg1;
10566 }
10567 {
10568 if (temp2)
10569 delete arg2;
10570 }
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 int arg1 = (int) 0 ;
10578 int arg2 = (int) 0 ;
10579 bool arg3 = (bool) true ;
10580 wxImage *result;
10581 PyObject * obj0 = 0 ;
10582 PyObject * obj1 = 0 ;
10583 PyObject * obj2 = 0 ;
10584 char *kwnames[] = {
10585 (char *) "width",(char *) "height",(char *) "clear", NULL
10586 };
10587
10588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10589 if (obj0) {
10590 {
10591 arg1 = (int)(SWIG_As_int(obj0));
10592 if (SWIG_arg_fail(1)) SWIG_fail;
10593 }
10594 }
10595 if (obj1) {
10596 {
10597 arg2 = (int)(SWIG_As_int(obj1));
10598 if (SWIG_arg_fail(2)) SWIG_fail;
10599 }
10600 }
10601 if (obj2) {
10602 {
10603 arg3 = (bool)(SWIG_As_bool(obj2));
10604 if (SWIG_arg_fail(3)) SWIG_fail;
10605 }
10606 }
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj;
10623 wxBitmap *arg1 = 0 ;
10624 wxImage *result;
10625 PyObject * obj0 = 0 ;
10626 char *kwnames[] = {
10627 (char *) "bitmap", NULL
10628 };
10629
10630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10631 {
10632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10633 if (SWIG_arg_fail(1)) SWIG_fail;
10634 if (arg1 == NULL) {
10635 SWIG_null_ref("wxBitmap");
10636 }
10637 if (SWIG_arg_fail(1)) SWIG_fail;
10638 }
10639 {
10640 if (!wxPyCheckForApp()) SWIG_fail;
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 int arg1 ;
10657 int arg2 ;
10658 unsigned char *arg3 = (unsigned char *) 0 ;
10659 wxImage *result;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 PyObject * obj2 = 0 ;
10663 char *kwnames[] = {
10664 (char *) "width",(char *) "height",(char *) "data", NULL
10665 };
10666
10667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10668 {
10669 arg1 = (int)(SWIG_As_int(obj0));
10670 if (SWIG_arg_fail(1)) SWIG_fail;
10671 }
10672 {
10673 arg2 = (int)(SWIG_As_int(obj1));
10674 if (SWIG_arg_fail(2)) SWIG_fail;
10675 }
10676 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10677 if (SWIG_arg_fail(3)) SWIG_fail;
10678 {
10679 PyThreadState* __tstate = wxPyBeginAllowThreads();
10680 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10681
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10693 PyObject *resultobj;
10694 int arg1 ;
10695 int arg2 ;
10696 unsigned char *arg3 = (unsigned char *) 0 ;
10697 unsigned char *arg4 = (unsigned char *) 0 ;
10698 wxImage *result;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10703 char *kwnames[] = {
10704 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10705 };
10706
10707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10708 {
10709 arg1 = (int)(SWIG_As_int(obj0));
10710 if (SWIG_arg_fail(1)) SWIG_fail;
10711 }
10712 {
10713 arg2 = (int)(SWIG_As_int(obj1));
10714 if (SWIG_arg_fail(2)) SWIG_fail;
10715 }
10716 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10717 if (SWIG_arg_fail(3)) SWIG_fail;
10718 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10719 if (SWIG_arg_fail(4)) SWIG_fail;
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10723
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 wxImage *arg1 = (wxImage *) 0 ;
10737 int arg2 ;
10738 int arg3 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 char *kwnames[] = {
10743 (char *) "self",(char *) "width",(char *) "height", NULL
10744 };
10745
10746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10748 if (SWIG_arg_fail(1)) SWIG_fail;
10749 {
10750 arg2 = (int)(SWIG_As_int(obj1));
10751 if (SWIG_arg_fail(2)) SWIG_fail;
10752 }
10753 {
10754 arg3 = (int)(SWIG_As_int(obj2));
10755 if (SWIG_arg_fail(3)) SWIG_fail;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->Create(arg2,arg3);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj;
10773 wxImage *arg1 = (wxImage *) 0 ;
10774 PyObject * obj0 = 0 ;
10775 char *kwnames[] = {
10776 (char *) "self", NULL
10777 };
10778
10779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10781 if (SWIG_arg_fail(1)) SWIG_fail;
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 (arg1)->Destroy();
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 Py_INCREF(Py_None); resultobj = Py_None;
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxImage *arg1 = (wxImage *) 0 ;
10799 int arg2 ;
10800 int arg3 ;
10801 SwigValueWrapper<wxImage > result;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 PyObject * obj2 = 0 ;
10805 char *kwnames[] = {
10806 (char *) "self",(char *) "width",(char *) "height", NULL
10807 };
10808
10809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10811 if (SWIG_arg_fail(1)) SWIG_fail;
10812 {
10813 arg2 = (int)(SWIG_As_int(obj1));
10814 if (SWIG_arg_fail(2)) SWIG_fail;
10815 }
10816 {
10817 arg3 = (int)(SWIG_As_int(obj2));
10818 if (SWIG_arg_fail(3)) SWIG_fail;
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (arg1)->Scale(arg2,arg3);
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 {
10828 wxImage * resultptr;
10829 resultptr = new wxImage((wxImage &)(result));
10830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10831 }
10832 return resultobj;
10833 fail:
10834 return NULL;
10835 }
10836
10837
10838 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj;
10840 wxImage *arg1 = (wxImage *) 0 ;
10841 int arg2 ;
10842 int arg3 ;
10843 SwigValueWrapper<wxImage > result;
10844 PyObject * obj0 = 0 ;
10845 PyObject * obj1 = 0 ;
10846 PyObject * obj2 = 0 ;
10847 char *kwnames[] = {
10848 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10849 };
10850
10851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10853 if (SWIG_arg_fail(1)) SWIG_fail;
10854 {
10855 arg2 = (int)(SWIG_As_int(obj1));
10856 if (SWIG_arg_fail(2)) SWIG_fail;
10857 }
10858 {
10859 arg3 = (int)(SWIG_As_int(obj2));
10860 if (SWIG_arg_fail(3)) SWIG_fail;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10865
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 wxImage * resultptr;
10871 resultptr = new wxImage((wxImage &)(result));
10872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10873 }
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxImage *arg1 = (wxImage *) 0 ;
10883 int arg2 ;
10884 int arg3 ;
10885 wxImage *result;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 PyObject * obj2 = 0 ;
10889 char *kwnames[] = {
10890 (char *) "self",(char *) "width",(char *) "height", NULL
10891 };
10892
10893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10895 if (SWIG_arg_fail(1)) SWIG_fail;
10896 {
10897 arg2 = (int)(SWIG_As_int(obj1));
10898 if (SWIG_arg_fail(2)) SWIG_fail;
10899 }
10900 {
10901 arg3 = (int)(SWIG_As_int(obj2));
10902 if (SWIG_arg_fail(3)) SWIG_fail;
10903 }
10904 {
10905 PyThreadState* __tstate = wxPyBeginAllowThreads();
10906 {
10907 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10908 result = (wxImage *) &_result_ref;
10909 }
10910
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxImage *arg1 = (wxImage *) 0 ;
10924 int arg2 ;
10925 int arg3 ;
10926 unsigned char arg4 ;
10927 unsigned char arg5 ;
10928 unsigned char arg6 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 PyObject * obj2 = 0 ;
10932 PyObject * obj3 = 0 ;
10933 PyObject * obj4 = 0 ;
10934 PyObject * obj5 = 0 ;
10935 char *kwnames[] = {
10936 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10937 };
10938
10939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10941 if (SWIG_arg_fail(1)) SWIG_fail;
10942 {
10943 arg2 = (int)(SWIG_As_int(obj1));
10944 if (SWIG_arg_fail(2)) SWIG_fail;
10945 }
10946 {
10947 arg3 = (int)(SWIG_As_int(obj2));
10948 if (SWIG_arg_fail(3)) SWIG_fail;
10949 }
10950 {
10951 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10952 if (SWIG_arg_fail(4)) SWIG_fail;
10953 }
10954 {
10955 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10956 if (SWIG_arg_fail(5)) SWIG_fail;
10957 }
10958 {
10959 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10960 if (SWIG_arg_fail(6)) SWIG_fail;
10961 }
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 Py_INCREF(Py_None); resultobj = Py_None;
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxImage *arg1 = (wxImage *) 0 ;
10979 int arg2 ;
10980 int arg3 ;
10981 unsigned char result;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 PyObject * obj2 = 0 ;
10985 char *kwnames[] = {
10986 (char *) "self",(char *) "x",(char *) "y", NULL
10987 };
10988
10989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10991 if (SWIG_arg_fail(1)) SWIG_fail;
10992 {
10993 arg2 = (int)(SWIG_As_int(obj1));
10994 if (SWIG_arg_fail(2)) SWIG_fail;
10995 }
10996 {
10997 arg3 = (int)(SWIG_As_int(obj2));
10998 if (SWIG_arg_fail(3)) SWIG_fail;
10999 }
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11003
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj;
11018 wxImage *arg1 = (wxImage *) 0 ;
11019 int arg2 ;
11020 int arg3 ;
11021 unsigned char result;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 PyObject * obj2 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "x",(char *) "y", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = (int)(SWIG_As_int(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 {
11037 arg3 = (int)(SWIG_As_int(obj2));
11038 if (SWIG_arg_fail(3)) SWIG_fail;
11039 }
11040 {
11041 PyThreadState* __tstate = wxPyBeginAllowThreads();
11042 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11043
11044 wxPyEndAllowThreads(__tstate);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 {
11048 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxImage *arg1 = (wxImage *) 0 ;
11059 int arg2 ;
11060 int arg3 ;
11061 unsigned char result;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "x",(char *) "y", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 {
11077 arg3 = (int)(SWIG_As_int(obj2));
11078 if (SWIG_arg_fail(3)) SWIG_fail;
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11083
11084 wxPyEndAllowThreads(__tstate);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 {
11088 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11089 }
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj;
11098 wxImage *arg1 = (wxImage *) 0 ;
11099 int arg2 ;
11100 int arg3 ;
11101 unsigned char arg4 ;
11102 PyObject * obj0 = 0 ;
11103 PyObject * obj1 = 0 ;
11104 PyObject * obj2 = 0 ;
11105 PyObject * obj3 = 0 ;
11106 char *kwnames[] = {
11107 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11108 };
11109
11110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11112 if (SWIG_arg_fail(1)) SWIG_fail;
11113 {
11114 arg2 = (int)(SWIG_As_int(obj1));
11115 if (SWIG_arg_fail(2)) SWIG_fail;
11116 }
11117 {
11118 arg3 = (int)(SWIG_As_int(obj2));
11119 if (SWIG_arg_fail(3)) SWIG_fail;
11120 }
11121 {
11122 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11123 if (SWIG_arg_fail(4)) SWIG_fail;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 (arg1)->SetAlpha(arg2,arg3,arg4);
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 Py_INCREF(Py_None); resultobj = Py_None;
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11140 PyObject *resultobj;
11141 wxImage *arg1 = (wxImage *) 0 ;
11142 int arg2 ;
11143 int arg3 ;
11144 unsigned char result;
11145 PyObject * obj0 = 0 ;
11146 PyObject * obj1 = 0 ;
11147 PyObject * obj2 = 0 ;
11148 char *kwnames[] = {
11149 (char *) "self",(char *) "x",(char *) "y", NULL
11150 };
11151
11152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11154 if (SWIG_arg_fail(1)) SWIG_fail;
11155 {
11156 arg2 = (int)(SWIG_As_int(obj1));
11157 if (SWIG_arg_fail(2)) SWIG_fail;
11158 }
11159 {
11160 arg3 = (int)(SWIG_As_int(obj2));
11161 if (SWIG_arg_fail(3)) SWIG_fail;
11162 }
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11166
11167 wxPyEndAllowThreads(__tstate);
11168 if (PyErr_Occurred()) SWIG_fail;
11169 }
11170 {
11171 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxImage *arg1 = (wxImage *) 0 ;
11182 bool result;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = (bool)(arg1)->HasAlpha();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 {
11199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11200 }
11201 return resultobj;
11202 fail:
11203 return NULL;
11204 }
11205
11206
11207 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 wxImage *arg1 = (wxImage *) 0 ;
11210 byte *arg2 = (byte *) 0 ;
11211 byte *arg3 = (byte *) 0 ;
11212 byte *arg4 = (byte *) 0 ;
11213 byte arg5 = (byte) 0 ;
11214 byte arg6 = (byte) 0 ;
11215 byte arg7 = (byte) 0 ;
11216 bool result;
11217 byte temp2 ;
11218 int res2 = 0 ;
11219 byte temp3 ;
11220 int res3 = 0 ;
11221 byte temp4 ;
11222 int res4 = 0 ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 PyObject * obj2 = 0 ;
11226 PyObject * obj3 = 0 ;
11227 char *kwnames[] = {
11228 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11229 };
11230
11231 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11232 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11233 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11236 if (SWIG_arg_fail(1)) SWIG_fail;
11237 if (obj1) {
11238 {
11239 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11240 if (SWIG_arg_fail(5)) SWIG_fail;
11241 }
11242 }
11243 if (obj2) {
11244 {
11245 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11246 if (SWIG_arg_fail(6)) SWIG_fail;
11247 }
11248 }
11249 if (obj3) {
11250 {
11251 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11252 if (SWIG_arg_fail(7)) SWIG_fail;
11253 }
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 {
11263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11264 }
11265 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11267 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11268 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11269 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11270 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11271 return resultobj;
11272 fail:
11273 return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj;
11279 wxImage *arg1 = (wxImage *) 0 ;
11280 byte arg2 = (byte) 128 ;
11281 bool result;
11282 PyObject * obj0 = 0 ;
11283 PyObject * obj1 = 0 ;
11284 char *kwnames[] = {
11285 (char *) "self",(char *) "threshold", NULL
11286 };
11287
11288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11290 if (SWIG_arg_fail(1)) SWIG_fail;
11291 if (obj1) {
11292 {
11293 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11294 if (SWIG_arg_fail(2)) SWIG_fail;
11295 }
11296 }
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11300
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 {
11305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11306 }
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj;
11315 wxImage *arg1 = (wxImage *) 0 ;
11316 unsigned char arg2 ;
11317 unsigned char arg3 ;
11318 unsigned char arg4 ;
11319 bool result;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 PyObject * obj2 = 0 ;
11323 PyObject * obj3 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11333 if (SWIG_arg_fail(2)) SWIG_fail;
11334 }
11335 {
11336 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11337 if (SWIG_arg_fail(3)) SWIG_fail;
11338 }
11339 {
11340 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11341 if (SWIG_arg_fail(4)) SWIG_fail;
11342 }
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11346
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11352 }
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj;
11361 wxImage *arg1 = (wxImage *) 0 ;
11362 wxImage *arg2 = 0 ;
11363 byte arg3 ;
11364 byte arg4 ;
11365 byte arg5 ;
11366 bool result;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 PyObject * obj3 = 0 ;
11371 PyObject * obj4 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 if (arg2 == NULL) {
11383 SWIG_null_ref("wxImage");
11384 }
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11393 if (SWIG_arg_fail(4)) SWIG_fail;
11394 }
11395 {
11396 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11397 if (SWIG_arg_fail(5)) SWIG_fail;
11398 }
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11402
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 {
11407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11408 }
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj;
11417 wxString *arg1 = 0 ;
11418 bool result;
11419 bool temp1 = false ;
11420 PyObject * obj0 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "name", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11426 {
11427 arg1 = wxString_in_helper(obj0);
11428 if (arg1 == NULL) SWIG_fail;
11429 temp1 = true;
11430 }
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11434
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 {
11439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11440 }
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return resultobj;
11446 fail:
11447 {
11448 if (temp1)
11449 delete arg1;
11450 }
11451 return NULL;
11452 }
11453
11454
11455 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj;
11457 wxString *arg1 = 0 ;
11458 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11459 int result;
11460 bool temp1 = false ;
11461 PyObject * obj0 = 0 ;
11462 PyObject * obj1 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "name",(char *) "type", NULL
11465 };
11466
11467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11468 {
11469 arg1 = wxString_in_helper(obj0);
11470 if (arg1 == NULL) SWIG_fail;
11471 temp1 = true;
11472 }
11473 if (obj1) {
11474 {
11475 arg2 = (long)(SWIG_As_long(obj1));
11476 if (SWIG_arg_fail(2)) SWIG_fail;
11477 }
11478 }
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11482
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = SWIG_From_int((int)(result));
11488 }
11489 {
11490 if (temp1)
11491 delete arg1;
11492 }
11493 return resultobj;
11494 fail:
11495 {
11496 if (temp1)
11497 delete arg1;
11498 }
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxImage *arg1 = (wxImage *) 0 ;
11506 wxString *arg2 = 0 ;
11507 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11508 int arg4 = (int) -1 ;
11509 bool result;
11510 bool temp2 = false ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 PyObject * obj2 = 0 ;
11514 PyObject * obj3 = 0 ;
11515 char *kwnames[] = {
11516 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11517 };
11518
11519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11521 if (SWIG_arg_fail(1)) SWIG_fail;
11522 {
11523 arg2 = wxString_in_helper(obj1);
11524 if (arg2 == NULL) SWIG_fail;
11525 temp2 = true;
11526 }
11527 if (obj2) {
11528 {
11529 arg3 = (long)(SWIG_As_long(obj2));
11530 if (SWIG_arg_fail(3)) SWIG_fail;
11531 }
11532 }
11533 if (obj3) {
11534 {
11535 arg4 = (int)(SWIG_As_int(obj3));
11536 if (SWIG_arg_fail(4)) SWIG_fail;
11537 }
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 {
11547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11548 }
11549 {
11550 if (temp2)
11551 delete arg2;
11552 }
11553 return resultobj;
11554 fail:
11555 {
11556 if (temp2)
11557 delete arg2;
11558 }
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxImage *arg1 = (wxImage *) 0 ;
11566 wxString *arg2 = 0 ;
11567 wxString *arg3 = 0 ;
11568 int arg4 = (int) -1 ;
11569 bool result;
11570 bool temp2 = false ;
11571 bool temp3 = false ;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 PyObject * obj2 = 0 ;
11575 PyObject * obj3 = 0 ;
11576 char *kwnames[] = {
11577 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11578 };
11579
11580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11582 if (SWIG_arg_fail(1)) SWIG_fail;
11583 {
11584 arg2 = wxString_in_helper(obj1);
11585 if (arg2 == NULL) SWIG_fail;
11586 temp2 = true;
11587 }
11588 {
11589 arg3 = wxString_in_helper(obj2);
11590 if (arg3 == NULL) SWIG_fail;
11591 temp3 = true;
11592 }
11593 if (obj3) {
11594 {
11595 arg4 = (int)(SWIG_As_int(obj3));
11596 if (SWIG_arg_fail(4)) SWIG_fail;
11597 }
11598 }
11599 {
11600 PyThreadState* __tstate = wxPyBeginAllowThreads();
11601 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11602
11603 wxPyEndAllowThreads(__tstate);
11604 if (PyErr_Occurred()) SWIG_fail;
11605 }
11606 {
11607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11608 }
11609 {
11610 if (temp2)
11611 delete arg2;
11612 }
11613 {
11614 if (temp3)
11615 delete arg3;
11616 }
11617 return resultobj;
11618 fail:
11619 {
11620 if (temp2)
11621 delete arg2;
11622 }
11623 {
11624 if (temp3)
11625 delete arg3;
11626 }
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxImage *arg1 = (wxImage *) 0 ;
11634 wxString *arg2 = 0 ;
11635 int arg3 ;
11636 bool result;
11637 bool temp2 = false ;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 PyObject * obj2 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self",(char *) "name",(char *) "type", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 arg2 = wxString_in_helper(obj1);
11650 if (arg2 == NULL) SWIG_fail;
11651 temp2 = true;
11652 }
11653 {
11654 arg3 = (int)(SWIG_As_int(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11666 }
11667 {
11668 if (temp2)
11669 delete arg2;
11670 }
11671 return resultobj;
11672 fail:
11673 {
11674 if (temp2)
11675 delete arg2;
11676 }
11677 return NULL;
11678 }
11679
11680
11681 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj;
11683 wxImage *arg1 = (wxImage *) 0 ;
11684 wxString *arg2 = 0 ;
11685 wxString *arg3 = 0 ;
11686 bool result;
11687 bool temp2 = false ;
11688 bool temp3 = false ;
11689 PyObject * obj0 = 0 ;
11690 PyObject * obj1 = 0 ;
11691 PyObject * obj2 = 0 ;
11692 char *kwnames[] = {
11693 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11694 };
11695
11696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11698 if (SWIG_arg_fail(1)) SWIG_fail;
11699 {
11700 arg2 = wxString_in_helper(obj1);
11701 if (arg2 == NULL) SWIG_fail;
11702 temp2 = true;
11703 }
11704 {
11705 arg3 = wxString_in_helper(obj2);
11706 if (arg3 == NULL) SWIG_fail;
11707 temp3 = true;
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11718 }
11719 {
11720 if (temp2)
11721 delete arg2;
11722 }
11723 {
11724 if (temp3)
11725 delete arg3;
11726 }
11727 return resultobj;
11728 fail:
11729 {
11730 if (temp2)
11731 delete arg2;
11732 }
11733 {
11734 if (temp3)
11735 delete arg3;
11736 }
11737 return NULL;
11738 }
11739
11740
11741 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11742 PyObject *resultobj;
11743 wxInputStream *arg1 = 0 ;
11744 bool result;
11745 wxPyInputStream *temp1 ;
11746 bool created1 ;
11747 PyObject * obj0 = 0 ;
11748 char *kwnames[] = {
11749 (char *) "stream", NULL
11750 };
11751
11752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11753 {
11754 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11755 arg1 = temp1->m_wxis;
11756 created1 = false;
11757 } else {
11758 PyErr_Clear(); // clear the failure of the wxPyConvert above
11759 arg1 = wxPyCBInputStream_create(obj0, false);
11760 if (arg1 == NULL) {
11761 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11762 SWIG_fail;
11763 }
11764 created1 = true;
11765 }
11766 }
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (bool)wxImage::CanRead(*arg1);
11770
11771 wxPyEndAllowThreads(__tstate);
11772 if (PyErr_Occurred()) SWIG_fail;
11773 }
11774 {
11775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11776 }
11777 {
11778 if (created1)
11779 delete arg1;
11780 }
11781 return resultobj;
11782 fail:
11783 {
11784 if (created1)
11785 delete arg1;
11786 }
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxImage *arg1 = (wxImage *) 0 ;
11794 wxInputStream *arg2 = 0 ;
11795 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11796 int arg4 = (int) -1 ;
11797 bool result;
11798 wxPyInputStream *temp2 ;
11799 bool created2 ;
11800 PyObject * obj0 = 0 ;
11801 PyObject * obj1 = 0 ;
11802 PyObject * obj2 = 0 ;
11803 PyObject * obj3 = 0 ;
11804 char *kwnames[] = {
11805 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11806 };
11807
11808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11810 if (SWIG_arg_fail(1)) SWIG_fail;
11811 {
11812 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11813 arg2 = temp2->m_wxis;
11814 created2 = false;
11815 } else {
11816 PyErr_Clear(); // clear the failure of the wxPyConvert above
11817 arg2 = wxPyCBInputStream_create(obj1, false);
11818 if (arg2 == NULL) {
11819 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11820 SWIG_fail;
11821 }
11822 created2 = true;
11823 }
11824 }
11825 if (obj2) {
11826 {
11827 arg3 = (long)(SWIG_As_long(obj2));
11828 if (SWIG_arg_fail(3)) SWIG_fail;
11829 }
11830 }
11831 if (obj3) {
11832 {
11833 arg4 = (int)(SWIG_As_int(obj3));
11834 if (SWIG_arg_fail(4)) SWIG_fail;
11835 }
11836 }
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11840
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11846 }
11847 {
11848 if (created2)
11849 delete arg2;
11850 }
11851 return resultobj;
11852 fail:
11853 {
11854 if (created2)
11855 delete arg2;
11856 }
11857 return NULL;
11858 }
11859
11860
11861 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11862 PyObject *resultobj;
11863 wxImage *arg1 = (wxImage *) 0 ;
11864 wxInputStream *arg2 = 0 ;
11865 wxString *arg3 = 0 ;
11866 int arg4 = (int) -1 ;
11867 bool result;
11868 wxPyInputStream *temp2 ;
11869 bool created2 ;
11870 bool temp3 = false ;
11871 PyObject * obj0 = 0 ;
11872 PyObject * obj1 = 0 ;
11873 PyObject * obj2 = 0 ;
11874 PyObject * obj3 = 0 ;
11875 char *kwnames[] = {
11876 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11877 };
11878
11879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11881 if (SWIG_arg_fail(1)) SWIG_fail;
11882 {
11883 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11884 arg2 = temp2->m_wxis;
11885 created2 = false;
11886 } else {
11887 PyErr_Clear(); // clear the failure of the wxPyConvert above
11888 arg2 = wxPyCBInputStream_create(obj1, false);
11889 if (arg2 == NULL) {
11890 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11891 SWIG_fail;
11892 }
11893 created2 = true;
11894 }
11895 }
11896 {
11897 arg3 = wxString_in_helper(obj2);
11898 if (arg3 == NULL) SWIG_fail;
11899 temp3 = true;
11900 }
11901 if (obj3) {
11902 {
11903 arg4 = (int)(SWIG_As_int(obj3));
11904 if (SWIG_arg_fail(4)) SWIG_fail;
11905 }
11906 }
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11910
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11916 }
11917 {
11918 if (created2)
11919 delete arg2;
11920 }
11921 {
11922 if (temp3)
11923 delete arg3;
11924 }
11925 return resultobj;
11926 fail:
11927 {
11928 if (created2)
11929 delete arg2;
11930 }
11931 {
11932 if (temp3)
11933 delete arg3;
11934 }
11935 return NULL;
11936 }
11937
11938
11939 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11940 PyObject *resultobj;
11941 wxImage *arg1 = (wxImage *) 0 ;
11942 bool result;
11943 PyObject * obj0 = 0 ;
11944 char *kwnames[] = {
11945 (char *) "self", NULL
11946 };
11947
11948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11950 if (SWIG_arg_fail(1)) SWIG_fail;
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->Ok();
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj;
11969 wxImage *arg1 = (wxImage *) 0 ;
11970 int result;
11971 PyObject * obj0 = 0 ;
11972 char *kwnames[] = {
11973 (char *) "self", NULL
11974 };
11975
11976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11978 if (SWIG_arg_fail(1)) SWIG_fail;
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (int)(arg1)->GetWidth();
11982
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 {
11987 resultobj = SWIG_From_int((int)(result));
11988 }
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj;
11997 wxImage *arg1 = (wxImage *) 0 ;
11998 int result;
11999 PyObject * obj0 = 0 ;
12000 char *kwnames[] = {
12001 (char *) "self", NULL
12002 };
12003
12004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12006 if (SWIG_arg_fail(1)) SWIG_fail;
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (int)(arg1)->GetHeight();
12010
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 resultobj = SWIG_From_int((int)(result));
12016 }
12017 return resultobj;
12018 fail:
12019 return NULL;
12020 }
12021
12022
12023 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12024 PyObject *resultobj;
12025 wxImage *arg1 = (wxImage *) 0 ;
12026 wxSize result;
12027 PyObject * obj0 = 0 ;
12028 char *kwnames[] = {
12029 (char *) "self", NULL
12030 };
12031
12032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12034 if (SWIG_arg_fail(1)) SWIG_fail;
12035 {
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 result = wxImage_GetSize(arg1);
12038
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 {
12043 wxSize * resultptr;
12044 resultptr = new wxSize((wxSize &)(result));
12045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12046 }
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 wxRect *arg2 = 0 ;
12057 SwigValueWrapper<wxImage > result;
12058 wxRect temp2 ;
12059 PyObject * obj0 = 0 ;
12060 PyObject * obj1 = 0 ;
12061 char *kwnames[] = {
12062 (char *) "self",(char *) "rect", NULL
12063 };
12064
12065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12067 if (SWIG_arg_fail(1)) SWIG_fail;
12068 {
12069 arg2 = &temp2;
12070 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12071 }
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12075
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 wxImage * resultptr;
12081 resultptr = new wxImage((wxImage &)(result));
12082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12083 }
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12091 PyObject *resultobj;
12092 wxImage *arg1 = (wxImage *) 0 ;
12093 SwigValueWrapper<wxImage > result;
12094 PyObject * obj0 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12101 if (SWIG_arg_fail(1)) SWIG_fail;
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 result = (arg1)->Copy();
12105
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 {
12110 wxImage * resultptr;
12111 resultptr = new wxImage((wxImage &)(result));
12112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12113 }
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj;
12122 wxImage *arg1 = (wxImage *) 0 ;
12123 wxImage *arg2 = 0 ;
12124 int arg3 ;
12125 int arg4 ;
12126 PyObject * obj0 = 0 ;
12127 PyObject * obj1 = 0 ;
12128 PyObject * obj2 = 0 ;
12129 PyObject * obj3 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 if (arg2 == NULL) {
12141 SWIG_null_ref("wxImage");
12142 }
12143 if (SWIG_arg_fail(2)) SWIG_fail;
12144 }
12145 {
12146 arg3 = (int)(SWIG_As_int(obj2));
12147 if (SWIG_arg_fail(3)) SWIG_fail;
12148 }
12149 {
12150 arg4 = (int)(SWIG_As_int(obj3));
12151 if (SWIG_arg_fail(4)) SWIG_fail;
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 Py_INCREF(Py_None); resultobj = Py_None;
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj;
12169 wxImage *arg1 = (wxImage *) 0 ;
12170 PyObject *result;
12171 PyObject * obj0 = 0 ;
12172 char *kwnames[] = {
12173 (char *) "self", NULL
12174 };
12175
12176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12178 if (SWIG_arg_fail(1)) SWIG_fail;
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (PyObject *)wxImage_GetData(arg1);
12182
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 resultobj = result;
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj;
12195 wxImage *arg1 = (wxImage *) 0 ;
12196 PyObject *arg2 = (PyObject *) 0 ;
12197 PyObject * obj0 = 0 ;
12198 PyObject * obj1 = 0 ;
12199 char *kwnames[] = {
12200 (char *) "self",(char *) "data", NULL
12201 };
12202
12203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12205 if (SWIG_arg_fail(1)) SWIG_fail;
12206 arg2 = obj1;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 wxImage_SetData(arg1,arg2);
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 Py_INCREF(Py_None); resultobj = Py_None;
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxImage *arg1 = (wxImage *) 0 ;
12224 PyObject *result;
12225 PyObject * obj0 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12236
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 resultobj = result;
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj;
12249 wxImage *arg1 = (wxImage *) 0 ;
12250 PyObject *arg2 = (PyObject *) 0 ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "self",(char *) "data", NULL
12255 };
12256
12257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12259 if (SWIG_arg_fail(1)) SWIG_fail;
12260 arg2 = obj1;
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 wxImage_SetDataBuffer(arg1,arg2);
12264
12265 wxPyEndAllowThreads(__tstate);
12266 if (PyErr_Occurred()) SWIG_fail;
12267 }
12268 Py_INCREF(Py_None); resultobj = Py_None;
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj;
12277 wxImage *arg1 = (wxImage *) 0 ;
12278 PyObject *result;
12279 PyObject * obj0 = 0 ;
12280 char *kwnames[] = {
12281 (char *) "self", NULL
12282 };
12283
12284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12286 if (SWIG_arg_fail(1)) SWIG_fail;
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (PyObject *)wxImage_GetAlphaData(arg1);
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = result;
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxImage *arg1 = (wxImage *) 0 ;
12304 PyObject *arg2 = (PyObject *) 0 ;
12305 PyObject * obj0 = 0 ;
12306 PyObject * obj1 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self",(char *) "data", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 arg2 = obj1;
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 wxImage_SetAlphaData(arg1,arg2);
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 Py_INCREF(Py_None); resultobj = Py_None;
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxImage *arg1 = (wxImage *) 0 ;
12332 PyObject *result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 resultobj = result;
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj;
12357 wxImage *arg1 = (wxImage *) 0 ;
12358 PyObject *arg2 = (PyObject *) 0 ;
12359 PyObject * obj0 = 0 ;
12360 PyObject * obj1 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self",(char *) "data", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 arg2 = obj1;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 wxImage_SetAlphaBuffer(arg1,arg2);
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 Py_INCREF(Py_None); resultobj = Py_None;
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj;
12385 wxImage *arg1 = (wxImage *) 0 ;
12386 unsigned char arg2 ;
12387 unsigned char arg3 ;
12388 unsigned char arg4 ;
12389 PyObject * obj0 = 0 ;
12390 PyObject * obj1 = 0 ;
12391 PyObject * obj2 = 0 ;
12392 PyObject * obj3 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12402 if (SWIG_arg_fail(2)) SWIG_fail;
12403 }
12404 {
12405 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12406 if (SWIG_arg_fail(3)) SWIG_fail;
12407 }
12408 {
12409 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12410 if (SWIG_arg_fail(4)) SWIG_fail;
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 (arg1)->SetMaskColour(arg2,arg3,arg4);
12415
12416 wxPyEndAllowThreads(__tstate);
12417 if (PyErr_Occurred()) SWIG_fail;
12418 }
12419 Py_INCREF(Py_None); resultobj = Py_None;
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj;
12428 wxImage *arg1 = (wxImage *) 0 ;
12429 unsigned char result;
12430 PyObject * obj0 = 0 ;
12431 char *kwnames[] = {
12432 (char *) "self", NULL
12433 };
12434
12435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12437 if (SWIG_arg_fail(1)) SWIG_fail;
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (unsigned char)(arg1)->GetMaskRed();
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12447 }
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj;
12456 wxImage *arg1 = (wxImage *) 0 ;
12457 unsigned char result;
12458 PyObject * obj0 = 0 ;
12459 char *kwnames[] = {
12460 (char *) "self", NULL
12461 };
12462
12463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12465 if (SWIG_arg_fail(1)) SWIG_fail;
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 result = (unsigned char)(arg1)->GetMaskGreen();
12469
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 {
12474 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12475 }
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12483 PyObject *resultobj;
12484 wxImage *arg1 = (wxImage *) 0 ;
12485 unsigned char result;
12486 PyObject * obj0 = 0 ;
12487 char *kwnames[] = {
12488 (char *) "self", NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12493 if (SWIG_arg_fail(1)) SWIG_fail;
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned char)(arg1)->GetMaskBlue();
12497
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 {
12502 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12503 }
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj;
12512 wxImage *arg1 = (wxImage *) 0 ;
12513 bool arg2 = (bool) true ;
12514 PyObject * obj0 = 0 ;
12515 PyObject * obj1 = 0 ;
12516 char *kwnames[] = {
12517 (char *) "self",(char *) "mask", NULL
12518 };
12519
12520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12522 if (SWIG_arg_fail(1)) SWIG_fail;
12523 if (obj1) {
12524 {
12525 arg2 = (bool)(SWIG_As_bool(obj1));
12526 if (SWIG_arg_fail(2)) SWIG_fail;
12527 }
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 (arg1)->SetMask(arg2);
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 Py_INCREF(Py_None); resultobj = Py_None;
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxImage *arg1 = (wxImage *) 0 ;
12546 bool result;
12547 PyObject * obj0 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = (bool)(arg1)->HasMask();
12558
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 {
12563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12564 }
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj;
12573 wxImage *arg1 = (wxImage *) 0 ;
12574 double arg2 ;
12575 wxPoint *arg3 = 0 ;
12576 bool arg4 = (bool) true ;
12577 wxPoint *arg5 = (wxPoint *) NULL ;
12578 SwigValueWrapper<wxImage > result;
12579 wxPoint temp3 ;
12580 PyObject * obj0 = 0 ;
12581 PyObject * obj1 = 0 ;
12582 PyObject * obj2 = 0 ;
12583 PyObject * obj3 = 0 ;
12584 PyObject * obj4 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = (double)(SWIG_As_double(obj1));
12594 if (SWIG_arg_fail(2)) SWIG_fail;
12595 }
12596 {
12597 arg3 = &temp3;
12598 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12599 }
12600 if (obj3) {
12601 {
12602 arg4 = (bool)(SWIG_As_bool(obj3));
12603 if (SWIG_arg_fail(4)) SWIG_fail;
12604 }
12605 }
12606 if (obj4) {
12607 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12608 if (SWIG_arg_fail(5)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12613
12614 wxPyEndAllowThreads(__tstate);
12615 if (PyErr_Occurred()) SWIG_fail;
12616 }
12617 {
12618 wxImage * resultptr;
12619 resultptr = new wxImage((wxImage &)(result));
12620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxImage *arg1 = (wxImage *) 0 ;
12631 bool arg2 = (bool) true ;
12632 SwigValueWrapper<wxImage > result;
12633 PyObject * obj0 = 0 ;
12634 PyObject * obj1 = 0 ;
12635 char *kwnames[] = {
12636 (char *) "self",(char *) "clockwise", NULL
12637 };
12638
12639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 if (obj1) {
12643 {
12644 arg2 = (bool)(SWIG_As_bool(obj1));
12645 if (SWIG_arg_fail(2)) SWIG_fail;
12646 }
12647 }
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (arg1)->Rotate90(arg2);
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 {
12656 wxImage * resultptr;
12657 resultptr = new wxImage((wxImage &)(result));
12658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxImage *arg1 = (wxImage *) 0 ;
12669 bool arg2 = (bool) true ;
12670 SwigValueWrapper<wxImage > result;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 char *kwnames[] = {
12674 (char *) "self",(char *) "horizontally", NULL
12675 };
12676
12677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12679 if (SWIG_arg_fail(1)) SWIG_fail;
12680 if (obj1) {
12681 {
12682 arg2 = (bool)(SWIG_As_bool(obj1));
12683 if (SWIG_arg_fail(2)) SWIG_fail;
12684 }
12685 }
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 result = (arg1)->Mirror(arg2);
12689
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 {
12694 wxImage * resultptr;
12695 resultptr = new wxImage((wxImage &)(result));
12696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxImage *arg1 = (wxImage *) 0 ;
12707 unsigned char arg2 ;
12708 unsigned char arg3 ;
12709 unsigned char arg4 ;
12710 unsigned char arg5 ;
12711 unsigned char arg6 ;
12712 unsigned char arg7 ;
12713 PyObject * obj0 = 0 ;
12714 PyObject * obj1 = 0 ;
12715 PyObject * obj2 = 0 ;
12716 PyObject * obj3 = 0 ;
12717 PyObject * obj4 = 0 ;
12718 PyObject * obj5 = 0 ;
12719 PyObject * obj6 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12729 if (SWIG_arg_fail(2)) SWIG_fail;
12730 }
12731 {
12732 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12733 if (SWIG_arg_fail(3)) SWIG_fail;
12734 }
12735 {
12736 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12737 if (SWIG_arg_fail(4)) SWIG_fail;
12738 }
12739 {
12740 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12741 if (SWIG_arg_fail(5)) SWIG_fail;
12742 }
12743 {
12744 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12745 if (SWIG_arg_fail(6)) SWIG_fail;
12746 }
12747 {
12748 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12749 if (SWIG_arg_fail(7)) SWIG_fail;
12750 }
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12754
12755 wxPyEndAllowThreads(__tstate);
12756 if (PyErr_Occurred()) SWIG_fail;
12757 }
12758 Py_INCREF(Py_None); resultobj = Py_None;
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj;
12767 wxImage *arg1 = (wxImage *) 0 ;
12768 unsigned char arg2 ;
12769 unsigned char arg3 ;
12770 unsigned char arg4 ;
12771 SwigValueWrapper<wxImage > result;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12774 PyObject * obj2 = 0 ;
12775 PyObject * obj3 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12785 if (SWIG_arg_fail(2)) SWIG_fail;
12786 }
12787 {
12788 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12789 if (SWIG_arg_fail(3)) SWIG_fail;
12790 }
12791 {
12792 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12793 if (SWIG_arg_fail(4)) SWIG_fail;
12794 }
12795 {
12796 PyThreadState* __tstate = wxPyBeginAllowThreads();
12797 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12798
12799 wxPyEndAllowThreads(__tstate);
12800 if (PyErr_Occurred()) SWIG_fail;
12801 }
12802 {
12803 wxImage * resultptr;
12804 resultptr = new wxImage((wxImage &)(result));
12805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12806 }
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 wxString *arg2 = 0 ;
12817 wxString *arg3 = 0 ;
12818 bool temp2 = false ;
12819 bool temp3 = false ;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 PyObject * obj2 = 0 ;
12823 char *kwnames[] = {
12824 (char *) "self",(char *) "name",(char *) "value", NULL
12825 };
12826
12827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) 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 = wxString_in_helper(obj1);
12832 if (arg2 == NULL) SWIG_fail;
12833 temp2 = true;
12834 }
12835 {
12836 arg3 = wxString_in_helper(obj2);
12837 if (arg3 == NULL) SWIG_fail;
12838 temp3 = true;
12839 }
12840 {
12841 PyThreadState* __tstate = wxPyBeginAllowThreads();
12842 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12843
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 Py_INCREF(Py_None); resultobj = Py_None;
12848 {
12849 if (temp2)
12850 delete arg2;
12851 }
12852 {
12853 if (temp3)
12854 delete arg3;
12855 }
12856 return resultobj;
12857 fail:
12858 {
12859 if (temp2)
12860 delete arg2;
12861 }
12862 {
12863 if (temp3)
12864 delete arg3;
12865 }
12866 return NULL;
12867 }
12868
12869
12870 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj;
12872 wxImage *arg1 = (wxImage *) 0 ;
12873 wxString *arg2 = 0 ;
12874 int arg3 ;
12875 bool temp2 = false ;
12876 PyObject * obj0 = 0 ;
12877 PyObject * obj1 = 0 ;
12878 PyObject * obj2 = 0 ;
12879 char *kwnames[] = {
12880 (char *) "self",(char *) "name",(char *) "value", NULL
12881 };
12882
12883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12885 if (SWIG_arg_fail(1)) SWIG_fail;
12886 {
12887 arg2 = wxString_in_helper(obj1);
12888 if (arg2 == NULL) SWIG_fail;
12889 temp2 = true;
12890 }
12891 {
12892 arg3 = (int)(SWIG_As_int(obj2));
12893 if (SWIG_arg_fail(3)) SWIG_fail;
12894 }
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 (arg1)->SetOption((wxString const &)*arg2,arg3);
12898
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 Py_INCREF(Py_None); resultobj = Py_None;
12903 {
12904 if (temp2)
12905 delete arg2;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (temp2)
12911 delete arg2;
12912 }
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 wxString *arg2 = 0 ;
12921 wxString result;
12922 bool temp2 = false ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self",(char *) "name", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 arg2 = wxString_in_helper(obj1);
12934 if (arg2 == NULL) SWIG_fail;
12935 temp2 = true;
12936 }
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12940
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 {
12945 #if wxUSE_UNICODE
12946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12947 #else
12948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12949 #endif
12950 }
12951 {
12952 if (temp2)
12953 delete arg2;
12954 }
12955 return resultobj;
12956 fail:
12957 {
12958 if (temp2)
12959 delete arg2;
12960 }
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 wxString *arg2 = 0 ;
12969 int result;
12970 bool temp2 = false ;
12971 PyObject * obj0 = 0 ;
12972 PyObject * obj1 = 0 ;
12973 char *kwnames[] = {
12974 (char *) "self",(char *) "name", NULL
12975 };
12976
12977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12979 if (SWIG_arg_fail(1)) SWIG_fail;
12980 {
12981 arg2 = wxString_in_helper(obj1);
12982 if (arg2 == NULL) SWIG_fail;
12983 temp2 = true;
12984 }
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 {
12993 resultobj = SWIG_From_int((int)(result));
12994 }
12995 {
12996 if (temp2)
12997 delete arg2;
12998 }
12999 return resultobj;
13000 fail:
13001 {
13002 if (temp2)
13003 delete arg2;
13004 }
13005 return NULL;
13006 }
13007
13008
13009 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj;
13011 wxImage *arg1 = (wxImage *) 0 ;
13012 wxString *arg2 = 0 ;
13013 bool result;
13014 bool temp2 = false ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self",(char *) "name", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 {
13025 arg2 = wxString_in_helper(obj1);
13026 if (arg2 == NULL) SWIG_fail;
13027 temp2 = true;
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 {
13037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13038 }
13039 {
13040 if (temp2)
13041 delete arg2;
13042 }
13043 return resultobj;
13044 fail:
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return NULL;
13050 }
13051
13052
13053 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj;
13055 wxImage *arg1 = (wxImage *) 0 ;
13056 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13057 unsigned long result;
13058 PyObject * obj0 = 0 ;
13059 PyObject * obj1 = 0 ;
13060 char *kwnames[] = {
13061 (char *) "self",(char *) "stopafter", NULL
13062 };
13063
13064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13066 if (SWIG_arg_fail(1)) SWIG_fail;
13067 if (obj1) {
13068 {
13069 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13070 if (SWIG_arg_fail(2)) SWIG_fail;
13071 }
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (unsigned long)(arg1)->CountColours(arg2);
13076
13077 wxPyEndAllowThreads(__tstate);
13078 if (PyErr_Occurred()) SWIG_fail;
13079 }
13080 {
13081 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13082 }
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj;
13091 wxImage *arg1 = (wxImage *) 0 ;
13092 wxImageHistogram *arg2 = 0 ;
13093 unsigned long result;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 char *kwnames[] = {
13097 (char *) "self",(char *) "h", NULL
13098 };
13099
13100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13102 if (SWIG_arg_fail(1)) SWIG_fail;
13103 {
13104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 if (arg2 == NULL) {
13107 SWIG_null_ref("wxImageHistogram");
13108 }
13109 if (SWIG_arg_fail(2)) SWIG_fail;
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13120 }
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj;
13129 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13130 PyObject * obj0 = 0 ;
13131 char *kwnames[] = {
13132 (char *) "handler", NULL
13133 };
13134
13135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(1)) SWIG_fail;
13138 {
13139 PyThreadState* __tstate = wxPyBeginAllowThreads();
13140 wxImage::AddHandler(arg1);
13141
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 Py_INCREF(Py_None); resultobj = Py_None;
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13153 PyObject *resultobj;
13154 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13155 PyObject * obj0 = 0 ;
13156 char *kwnames[] = {
13157 (char *) "handler", NULL
13158 };
13159
13160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13162 if (SWIG_arg_fail(1)) SWIG_fail;
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 wxImage::InsertHandler(arg1);
13166
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 Py_INCREF(Py_None); resultobj = Py_None;
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxString *arg1 = 0 ;
13180 bool result;
13181 bool temp1 = false ;
13182 PyObject * obj0 = 0 ;
13183 char *kwnames[] = {
13184 (char *) "name", NULL
13185 };
13186
13187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13188 {
13189 arg1 = wxString_in_helper(obj0);
13190 if (arg1 == NULL) SWIG_fail;
13191 temp1 = true;
13192 }
13193 {
13194 PyThreadState* __tstate = wxPyBeginAllowThreads();
13195 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13196
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 {
13201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13202 }
13203 {
13204 if (temp1)
13205 delete arg1;
13206 }
13207 return resultobj;
13208 fail:
13209 {
13210 if (temp1)
13211 delete arg1;
13212 }
13213 return NULL;
13214 }
13215
13216
13217 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj;
13219 wxString result;
13220 char *kwnames[] = {
13221 NULL
13222 };
13223
13224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = wxImage::GetImageExtWildcard();
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 {
13233 #if wxUSE_UNICODE
13234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13235 #else
13236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13237 #endif
13238 }
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj;
13247 wxImage *arg1 = (wxImage *) 0 ;
13248 int arg2 = (int) -1 ;
13249 wxBitmap result;
13250 PyObject * obj0 = 0 ;
13251 PyObject * obj1 = 0 ;
13252 char *kwnames[] = {
13253 (char *) "self",(char *) "depth", NULL
13254 };
13255
13256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13258 if (SWIG_arg_fail(1)) SWIG_fail;
13259 if (obj1) {
13260 {
13261 arg2 = (int)(SWIG_As_int(obj1));
13262 if (SWIG_arg_fail(2)) SWIG_fail;
13263 }
13264 }
13265 {
13266 if (!wxPyCheckForApp()) SWIG_fail;
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = wxImage_ConvertToBitmap(arg1,arg2);
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 {
13274 wxBitmap * resultptr;
13275 resultptr = new wxBitmap((wxBitmap &)(result));
13276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13277 }
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13285 PyObject *resultobj;
13286 wxImage *arg1 = (wxImage *) 0 ;
13287 unsigned char arg2 ;
13288 unsigned char arg3 ;
13289 unsigned char arg4 ;
13290 wxBitmap result;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 PyObject * obj2 = 0 ;
13294 PyObject * obj3 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13304 if (SWIG_arg_fail(2)) SWIG_fail;
13305 }
13306 {
13307 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13308 if (SWIG_arg_fail(3)) SWIG_fail;
13309 }
13310 {
13311 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13312 if (SWIG_arg_fail(4)) SWIG_fail;
13313 }
13314 {
13315 if (!wxPyCheckForApp()) SWIG_fail;
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 wxBitmap * resultptr;
13324 resultptr = new wxBitmap((wxBitmap &)(result));
13325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13326 }
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13334 PyObject *obj;
13335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13336 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13337 Py_INCREF(obj);
13338 return Py_BuildValue((char *)"");
13339 }
13340 static int _wrap_NullImage_set(PyObject *) {
13341 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13342 return 1;
13343 }
13344
13345
13346 static PyObject *_wrap_NullImage_get(void) {
13347 PyObject *pyobj;
13348
13349 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13350 return pyobj;
13351 }
13352
13353
13354 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13355 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13356 return 1;
13357 }
13358
13359
13360 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13361 PyObject *pyobj;
13362
13363 {
13364 #if wxUSE_UNICODE
13365 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13366 #else
13367 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13368 #endif
13369 }
13370 return pyobj;
13371 }
13372
13373
13374 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13375 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13376 return 1;
13377 }
13378
13379
13380 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13381 PyObject *pyobj;
13382
13383 {
13384 #if wxUSE_UNICODE
13385 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13386 #else
13387 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13388 #endif
13389 }
13390 return pyobj;
13391 }
13392
13393
13394 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13395 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13396 return 1;
13397 }
13398
13399
13400 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13401 PyObject *pyobj;
13402
13403 {
13404 #if wxUSE_UNICODE
13405 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13406 #else
13407 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13408 #endif
13409 }
13410 return pyobj;
13411 }
13412
13413
13414 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13415 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13416 return 1;
13417 }
13418
13419
13420 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13421 PyObject *pyobj;
13422
13423 {
13424 #if wxUSE_UNICODE
13425 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13426 #else
13427 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13428 #endif
13429 }
13430 return pyobj;
13431 }
13432
13433
13434 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13435 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13436 return 1;
13437 }
13438
13439
13440 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13441 PyObject *pyobj;
13442
13443 {
13444 #if wxUSE_UNICODE
13445 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13446 #else
13447 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13448 #endif
13449 }
13450 return pyobj;
13451 }
13452
13453
13454 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj;
13456 wxBMPHandler *result;
13457 char *kwnames[] = {
13458 NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 result = (wxBMPHandler *)new wxBMPHandler();
13465
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13477 PyObject *obj;
13478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13479 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13480 Py_INCREF(obj);
13481 return Py_BuildValue((char *)"");
13482 }
13483 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj;
13485 wxICOHandler *result;
13486 char *kwnames[] = {
13487 NULL
13488 };
13489
13490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (wxICOHandler *)new wxICOHandler();
13494
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13506 PyObject *obj;
13507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13508 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13509 Py_INCREF(obj);
13510 return Py_BuildValue((char *)"");
13511 }
13512 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxCURHandler *result;
13515 char *kwnames[] = {
13516 NULL
13517 };
13518
13519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13520 {
13521 PyThreadState* __tstate = wxPyBeginAllowThreads();
13522 result = (wxCURHandler *)new wxCURHandler();
13523
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13535 PyObject *obj;
13536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13537 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13538 Py_INCREF(obj);
13539 return Py_BuildValue((char *)"");
13540 }
13541 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxANIHandler *result;
13544 char *kwnames[] = {
13545 NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 result = (wxANIHandler *)new wxANIHandler();
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13564 PyObject *obj;
13565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13566 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13567 Py_INCREF(obj);
13568 return Py_BuildValue((char *)"");
13569 }
13570 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxPNGHandler *result;
13573 char *kwnames[] = {
13574 NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (wxPNGHandler *)new wxPNGHandler();
13581
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13593 PyObject *obj;
13594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13595 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13596 Py_INCREF(obj);
13597 return Py_BuildValue((char *)"");
13598 }
13599 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj;
13601 wxGIFHandler *result;
13602 char *kwnames[] = {
13603 NULL
13604 };
13605
13606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (wxGIFHandler *)new wxGIFHandler();
13610
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13622 PyObject *obj;
13623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13624 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13625 Py_INCREF(obj);
13626 return Py_BuildValue((char *)"");
13627 }
13628 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxPCXHandler *result;
13631 char *kwnames[] = {
13632 NULL
13633 };
13634
13635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (wxPCXHandler *)new wxPCXHandler();
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13651 PyObject *obj;
13652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13653 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13654 Py_INCREF(obj);
13655 return Py_BuildValue((char *)"");
13656 }
13657 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj;
13659 wxJPEGHandler *result;
13660 char *kwnames[] = {
13661 NULL
13662 };
13663
13664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (wxJPEGHandler *)new wxJPEGHandler();
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13680 PyObject *obj;
13681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13682 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13683 Py_INCREF(obj);
13684 return Py_BuildValue((char *)"");
13685 }
13686 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj;
13688 wxPNMHandler *result;
13689 char *kwnames[] = {
13690 NULL
13691 };
13692
13693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (wxPNMHandler *)new wxPNMHandler();
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13702 return resultobj;
13703 fail:
13704 return NULL;
13705 }
13706
13707
13708 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13709 PyObject *obj;
13710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13711 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13712 Py_INCREF(obj);
13713 return Py_BuildValue((char *)"");
13714 }
13715 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj;
13717 wxXPMHandler *result;
13718 char *kwnames[] = {
13719 NULL
13720 };
13721
13722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 result = (wxXPMHandler *)new wxXPMHandler();
13726
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13738 PyObject *obj;
13739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13740 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13741 Py_INCREF(obj);
13742 return Py_BuildValue((char *)"");
13743 }
13744 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13745 PyObject *resultobj;
13746 wxTIFFHandler *result;
13747 char *kwnames[] = {
13748 NULL
13749 };
13750
13751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13752 {
13753 PyThreadState* __tstate = wxPyBeginAllowThreads();
13754 result = (wxTIFFHandler *)new wxTIFFHandler();
13755
13756 wxPyEndAllowThreads(__tstate);
13757 if (PyErr_Occurred()) SWIG_fail;
13758 }
13759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13760 return resultobj;
13761 fail:
13762 return NULL;
13763 }
13764
13765
13766 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13767 PyObject *obj;
13768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13769 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13770 Py_INCREF(obj);
13771 return Py_BuildValue((char *)"");
13772 }
13773 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj;
13775 wxImage *arg1 = 0 ;
13776 wxImage *arg2 = 0 ;
13777 int arg3 = (int) 236 ;
13778 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13779 bool result;
13780 PyObject * obj0 = 0 ;
13781 PyObject * obj1 = 0 ;
13782 PyObject * obj2 = 0 ;
13783 PyObject * obj3 = 0 ;
13784 char *kwnames[] = {
13785 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13786 };
13787
13788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13789 {
13790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13791 if (SWIG_arg_fail(1)) SWIG_fail;
13792 if (arg1 == NULL) {
13793 SWIG_null_ref("wxImage");
13794 }
13795 if (SWIG_arg_fail(1)) SWIG_fail;
13796 }
13797 {
13798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13799 if (SWIG_arg_fail(2)) SWIG_fail;
13800 if (arg2 == NULL) {
13801 SWIG_null_ref("wxImage");
13802 }
13803 if (SWIG_arg_fail(2)) SWIG_fail;
13804 }
13805 if (obj2) {
13806 {
13807 arg3 = (int)(SWIG_As_int(obj2));
13808 if (SWIG_arg_fail(3)) SWIG_fail;
13809 }
13810 }
13811 if (obj3) {
13812 {
13813 arg4 = (int)(SWIG_As_int(obj3));
13814 if (SWIG_arg_fail(4)) SWIG_fail;
13815 }
13816 }
13817 {
13818 PyThreadState* __tstate = wxPyBeginAllowThreads();
13819 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13820
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 {
13825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13826 }
13827 return resultobj;
13828 fail:
13829 return NULL;
13830 }
13831
13832
13833 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13834 PyObject *obj;
13835 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13836 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13837 Py_INCREF(obj);
13838 return Py_BuildValue((char *)"");
13839 }
13840 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj;
13842 wxEvtHandler *result;
13843 char *kwnames[] = {
13844 NULL
13845 };
13846
13847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13848 {
13849 PyThreadState* __tstate = wxPyBeginAllowThreads();
13850 result = (wxEvtHandler *)new wxEvtHandler();
13851
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13856 return resultobj;
13857 fail:
13858 return NULL;
13859 }
13860
13861
13862 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj;
13864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13865 wxEvtHandler *result;
13866 PyObject * obj0 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13873 if (SWIG_arg_fail(1)) SWIG_fail;
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13877
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 {
13882 resultobj = wxPyMake_wxObject(result, 0);
13883 }
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj;
13892 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13893 wxEvtHandler *result;
13894 PyObject * obj0 = 0 ;
13895 char *kwnames[] = {
13896 (char *) "self", NULL
13897 };
13898
13899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13901 if (SWIG_arg_fail(1)) SWIG_fail;
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13905
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 {
13910 resultobj = wxPyMake_wxObject(result, 0);
13911 }
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13921 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13922 PyObject * obj0 = 0 ;
13923 PyObject * obj1 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self",(char *) "handler", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13932 if (SWIG_arg_fail(2)) SWIG_fail;
13933 {
13934 PyThreadState* __tstate = wxPyBeginAllowThreads();
13935 (arg1)->SetNextHandler(arg2);
13936
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 Py_INCREF(Py_None); resultobj = Py_None;
13941 return resultobj;
13942 fail:
13943 return NULL;
13944 }
13945
13946
13947 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj;
13949 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13950 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "self",(char *) "handler", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(1)) SWIG_fail;
13960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13961 if (SWIG_arg_fail(2)) SWIG_fail;
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 (arg1)->SetPreviousHandler(arg2);
13965
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 Py_INCREF(Py_None); resultobj = Py_None;
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj;
13978 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13979 bool result;
13980 PyObject * obj0 = 0 ;
13981 char *kwnames[] = {
13982 (char *) "self", NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13987 if (SWIG_arg_fail(1)) SWIG_fail;
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (bool)(arg1)->GetEvtHandlerEnabled();
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 {
13996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13997 }
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj;
14006 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14007 bool arg2 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self",(char *) "enabled", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 arg2 = (bool)(SWIG_As_bool(obj1));
14019 if (SWIG_arg_fail(2)) SWIG_fail;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 (arg1)->SetEvtHandlerEnabled(arg2);
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 Py_INCREF(Py_None); resultobj = Py_None;
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14038 wxEvent *arg2 = 0 ;
14039 bool result;
14040 PyObject * obj0 = 0 ;
14041 PyObject * obj1 = 0 ;
14042 char *kwnames[] = {
14043 (char *) "self",(char *) "event", NULL
14044 };
14045
14046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14048 if (SWIG_arg_fail(1)) SWIG_fail;
14049 {
14050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14051 if (SWIG_arg_fail(2)) SWIG_fail;
14052 if (arg2 == NULL) {
14053 SWIG_null_ref("wxEvent");
14054 }
14055 if (SWIG_arg_fail(2)) SWIG_fail;
14056 }
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 result = (bool)(arg1)->ProcessEvent(*arg2);
14060
14061 wxPyEndAllowThreads(__tstate);
14062 if (PyErr_Occurred()) SWIG_fail;
14063 }
14064 {
14065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14066 }
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj;
14075 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14076 wxEvent *arg2 = 0 ;
14077 PyObject * obj0 = 0 ;
14078 PyObject * obj1 = 0 ;
14079 char *kwnames[] = {
14080 (char *) "self",(char *) "event", NULL
14081 };
14082
14083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14085 if (SWIG_arg_fail(1)) SWIG_fail;
14086 {
14087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14088 if (SWIG_arg_fail(2)) SWIG_fail;
14089 if (arg2 == NULL) {
14090 SWIG_null_ref("wxEvent");
14091 }
14092 if (SWIG_arg_fail(2)) SWIG_fail;
14093 }
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 (arg1)->AddPendingEvent(*arg2);
14097
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 Py_INCREF(Py_None); resultobj = Py_None;
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14109 PyObject *resultobj;
14110 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14111 PyObject * obj0 = 0 ;
14112 char *kwnames[] = {
14113 (char *) "self", NULL
14114 };
14115
14116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14118 if (SWIG_arg_fail(1)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 (arg1)->ProcessPendingEvents();
14122
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 Py_INCREF(Py_None); resultobj = Py_None;
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14134 PyObject *resultobj;
14135 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14136 int arg2 ;
14137 int arg3 ;
14138 int arg4 ;
14139 PyObject *arg5 = (PyObject *) 0 ;
14140 PyObject * obj0 = 0 ;
14141 PyObject * obj1 = 0 ;
14142 PyObject * obj2 = 0 ;
14143 PyObject * obj3 = 0 ;
14144 PyObject * obj4 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 arg2 = (int)(SWIG_As_int(obj1));
14154 if (SWIG_arg_fail(2)) SWIG_fail;
14155 }
14156 {
14157 arg3 = (int)(SWIG_As_int(obj2));
14158 if (SWIG_arg_fail(3)) SWIG_fail;
14159 }
14160 {
14161 arg4 = (int)(SWIG_As_int(obj3));
14162 if (SWIG_arg_fail(4)) SWIG_fail;
14163 }
14164 arg5 = obj4;
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 Py_INCREF(Py_None); resultobj = Py_None;
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14182 int arg2 ;
14183 int arg3 = (int) -1 ;
14184 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14185 bool result;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 PyObject * obj3 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 arg2 = (int)(SWIG_As_int(obj1));
14199 if (SWIG_arg_fail(2)) SWIG_fail;
14200 }
14201 if (obj2) {
14202 {
14203 arg3 = (int)(SWIG_As_int(obj2));
14204 if (SWIG_arg_fail(3)) SWIG_fail;
14205 }
14206 }
14207 if (obj3) {
14208 {
14209 arg4 = (wxEventType)(SWIG_As_int(obj3));
14210 if (SWIG_arg_fail(4)) SWIG_fail;
14211 }
14212 }
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 {
14221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14222 }
14223 return resultobj;
14224 fail:
14225 return NULL;
14226 }
14227
14228
14229 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14232 PyObject *arg2 = (PyObject *) 0 ;
14233 bool arg3 = (bool) true ;
14234 PyObject * obj0 = 0 ;
14235 PyObject * obj1 = 0 ;
14236 PyObject * obj2 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self",(char *) "_self",(char *) "incref", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 arg2 = obj1;
14245 if (obj2) {
14246 {
14247 arg3 = (bool)(SWIG_As_bool(obj2));
14248 if (SWIG_arg_fail(3)) SWIG_fail;
14249 }
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 Py_INCREF(Py_None); resultobj = Py_None;
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14266 PyObject *obj;
14267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14268 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14269 Py_INCREF(obj);
14270 return Py_BuildValue((char *)"");
14271 }
14272 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj;
14274 wxEventType result;
14275 char *kwnames[] = {
14276 NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (wxEventType)wxNewEventType();
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 {
14288 resultobj = SWIG_From_int((int)(result));
14289 }
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj;
14298 wxEvent *arg1 = (wxEvent *) 0 ;
14299 PyObject * obj0 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "self", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14306 if (SWIG_arg_fail(1)) SWIG_fail;
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 delete arg1;
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 Py_INCREF(Py_None); resultobj = Py_None;
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxEvent *arg1 = (wxEvent *) 0 ;
14324 wxEventType arg2 ;
14325 PyObject * obj0 = 0 ;
14326 PyObject * obj1 = 0 ;
14327 char *kwnames[] = {
14328 (char *) "self",(char *) "typ", NULL
14329 };
14330
14331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14333 if (SWIG_arg_fail(1)) SWIG_fail;
14334 {
14335 arg2 = (wxEventType)(SWIG_As_int(obj1));
14336 if (SWIG_arg_fail(2)) SWIG_fail;
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->SetEventType(arg2);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxEvent *arg1 = (wxEvent *) 0 ;
14355 wxEventType result;
14356 PyObject * obj0 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "self", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = SWIG_From_int((int)(result));
14373 }
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14381 PyObject *resultobj;
14382 wxEvent *arg1 = (wxEvent *) 0 ;
14383 wxObject *result;
14384 PyObject * obj0 = 0 ;
14385 char *kwnames[] = {
14386 (char *) "self", NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14391 if (SWIG_arg_fail(1)) SWIG_fail;
14392 {
14393 PyThreadState* __tstate = wxPyBeginAllowThreads();
14394 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14395
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 {
14400 resultobj = wxPyMake_wxObject(result, 0);
14401 }
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj;
14410 wxEvent *arg1 = (wxEvent *) 0 ;
14411 wxObject *arg2 = (wxObject *) 0 ;
14412 PyObject * obj0 = 0 ;
14413 PyObject * obj1 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self",(char *) "obj", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14422 if (SWIG_arg_fail(2)) SWIG_fail;
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 (arg1)->SetEventObject(arg2);
14426
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 Py_INCREF(Py_None); resultobj = Py_None;
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj;
14439 wxEvent *arg1 = (wxEvent *) 0 ;
14440 long result;
14441 PyObject * obj0 = 0 ;
14442 char *kwnames[] = {
14443 (char *) "self", NULL
14444 };
14445
14446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14448 if (SWIG_arg_fail(1)) SWIG_fail;
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 {
14457 resultobj = SWIG_From_long((long)(result));
14458 }
14459 return resultobj;
14460 fail:
14461 return NULL;
14462 }
14463
14464
14465 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj;
14467 wxEvent *arg1 = (wxEvent *) 0 ;
14468 long arg2 = (long) 0 ;
14469 PyObject * obj0 = 0 ;
14470 PyObject * obj1 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self",(char *) "ts", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14477 if (SWIG_arg_fail(1)) SWIG_fail;
14478 if (obj1) {
14479 {
14480 arg2 = (long)(SWIG_As_long(obj1));
14481 if (SWIG_arg_fail(2)) SWIG_fail;
14482 }
14483 }
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 (arg1)->SetTimestamp(arg2);
14487
14488 wxPyEndAllowThreads(__tstate);
14489 if (PyErr_Occurred()) SWIG_fail;
14490 }
14491 Py_INCREF(Py_None); resultobj = Py_None;
14492 return resultobj;
14493 fail:
14494 return NULL;
14495 }
14496
14497
14498 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj;
14500 wxEvent *arg1 = (wxEvent *) 0 ;
14501 int result;
14502 PyObject * obj0 = 0 ;
14503 char *kwnames[] = {
14504 (char *) "self", NULL
14505 };
14506
14507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14509 if (SWIG_arg_fail(1)) SWIG_fail;
14510 {
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 result = (int)((wxEvent const *)arg1)->GetId();
14513
14514 wxPyEndAllowThreads(__tstate);
14515 if (PyErr_Occurred()) SWIG_fail;
14516 }
14517 {
14518 resultobj = SWIG_From_int((int)(result));
14519 }
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14527 PyObject *resultobj;
14528 wxEvent *arg1 = (wxEvent *) 0 ;
14529 int arg2 ;
14530 PyObject * obj0 = 0 ;
14531 PyObject * obj1 = 0 ;
14532 char *kwnames[] = {
14533 (char *) "self",(char *) "Id", NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14538 if (SWIG_arg_fail(1)) SWIG_fail;
14539 {
14540 arg2 = (int)(SWIG_As_int(obj1));
14541 if (SWIG_arg_fail(2)) SWIG_fail;
14542 }
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->SetId(arg2);
14546
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 Py_INCREF(Py_None); resultobj = Py_None;
14551 return resultobj;
14552 fail:
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxEvent *arg1 = (wxEvent *) 0 ;
14560 bool result;
14561 PyObject * obj0 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14572
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 {
14577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14578 }
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxEvent *arg1 = (wxEvent *) 0 ;
14588 bool arg2 = (bool) true ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self",(char *) "skip", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 if (obj1) {
14599 {
14600 arg2 = (bool)(SWIG_As_bool(obj1));
14601 if (SWIG_arg_fail(2)) SWIG_fail;
14602 }
14603 }
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 (arg1)->Skip(arg2);
14607
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 Py_INCREF(Py_None); resultobj = Py_None;
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj;
14620 wxEvent *arg1 = (wxEvent *) 0 ;
14621 bool result;
14622 PyObject * obj0 = 0 ;
14623 char *kwnames[] = {
14624 (char *) "self", NULL
14625 };
14626
14627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14629 if (SWIG_arg_fail(1)) SWIG_fail;
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14633
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 {
14638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14639 }
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14647 PyObject *resultobj;
14648 wxEvent *arg1 = (wxEvent *) 0 ;
14649 bool result;
14650 PyObject * obj0 = 0 ;
14651 char *kwnames[] = {
14652 (char *) "self", NULL
14653 };
14654
14655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14657 if (SWIG_arg_fail(1)) SWIG_fail;
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14661
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxEvent *arg1 = (wxEvent *) 0 ;
14677 int result;
14678 PyObject * obj0 = 0 ;
14679 char *kwnames[] = {
14680 (char *) "self", NULL
14681 };
14682
14683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14685 if (SWIG_arg_fail(1)) SWIG_fail;
14686 {
14687 PyThreadState* __tstate = wxPyBeginAllowThreads();
14688 result = (int)(arg1)->StopPropagation();
14689
14690 wxPyEndAllowThreads(__tstate);
14691 if (PyErr_Occurred()) SWIG_fail;
14692 }
14693 {
14694 resultobj = SWIG_From_int((int)(result));
14695 }
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj;
14704 wxEvent *arg1 = (wxEvent *) 0 ;
14705 int arg2 ;
14706 PyObject * obj0 = 0 ;
14707 PyObject * obj1 = 0 ;
14708 char *kwnames[] = {
14709 (char *) "self",(char *) "propagationLevel", NULL
14710 };
14711
14712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14714 if (SWIG_arg_fail(1)) SWIG_fail;
14715 {
14716 arg2 = (int)(SWIG_As_int(obj1));
14717 if (SWIG_arg_fail(2)) SWIG_fail;
14718 }
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 (arg1)->ResumePropagation(arg2);
14722
14723 wxPyEndAllowThreads(__tstate);
14724 if (PyErr_Occurred()) SWIG_fail;
14725 }
14726 Py_INCREF(Py_None); resultobj = Py_None;
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj;
14735 wxEvent *arg1 = (wxEvent *) 0 ;
14736 wxEvent *result;
14737 PyObject * obj0 = 0 ;
14738 char *kwnames[] = {
14739 (char *) "self", NULL
14740 };
14741
14742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14744 if (SWIG_arg_fail(1)) SWIG_fail;
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (wxEvent *)(arg1)->Clone();
14748
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14760 PyObject *obj;
14761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14762 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14763 Py_INCREF(obj);
14764 return Py_BuildValue((char *)"");
14765 }
14766 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxEvent *arg1 = 0 ;
14769 wxPropagationDisabler *result;
14770 PyObject * obj0 = 0 ;
14771 char *kwnames[] = {
14772 (char *) "event", NULL
14773 };
14774
14775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14776 {
14777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 if (arg1 == NULL) {
14780 SWIG_null_ref("wxEvent");
14781 }
14782 if (SWIG_arg_fail(1)) SWIG_fail;
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14787
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj;
14800 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14801 PyObject * obj0 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 delete arg1;
14812
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 Py_INCREF(Py_None); resultobj = Py_None;
14817 return resultobj;
14818 fail:
14819 return NULL;
14820 }
14821
14822
14823 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14824 PyObject *obj;
14825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14826 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14827 Py_INCREF(obj);
14828 return Py_BuildValue((char *)"");
14829 }
14830 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj;
14832 wxEvent *arg1 = 0 ;
14833 wxPropagateOnce *result;
14834 PyObject * obj0 = 0 ;
14835 char *kwnames[] = {
14836 (char *) "event", NULL
14837 };
14838
14839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14840 {
14841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14842 if (SWIG_arg_fail(1)) SWIG_fail;
14843 if (arg1 == NULL) {
14844 SWIG_null_ref("wxEvent");
14845 }
14846 if (SWIG_arg_fail(1)) SWIG_fail;
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14863 PyObject *resultobj;
14864 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14865 PyObject * obj0 = 0 ;
14866 char *kwnames[] = {
14867 (char *) "self", NULL
14868 };
14869
14870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14872 if (SWIG_arg_fail(1)) SWIG_fail;
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 delete arg1;
14876
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 Py_INCREF(Py_None); resultobj = Py_None;
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14888 PyObject *obj;
14889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14890 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14891 Py_INCREF(obj);
14892 return Py_BuildValue((char *)"");
14893 }
14894 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14897 int arg2 = (int) 0 ;
14898 wxCommandEvent *result;
14899 PyObject * obj0 = 0 ;
14900 PyObject * obj1 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "commandType",(char *) "winid", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14906 if (obj0) {
14907 {
14908 arg1 = (wxEventType)(SWIG_As_int(obj0));
14909 if (SWIG_arg_fail(1)) SWIG_fail;
14910 }
14911 }
14912 if (obj1) {
14913 {
14914 arg2 = (int)(SWIG_As_int(obj1));
14915 if (SWIG_arg_fail(2)) SWIG_fail;
14916 }
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14921
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14935 int result;
14936 PyObject * obj0 = 0 ;
14937 char *kwnames[] = {
14938 (char *) "self", NULL
14939 };
14940
14941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14943 if (SWIG_arg_fail(1)) SWIG_fail;
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14947
14948 wxPyEndAllowThreads(__tstate);
14949 if (PyErr_Occurred()) SWIG_fail;
14950 }
14951 {
14952 resultobj = SWIG_From_int((int)(result));
14953 }
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj;
14962 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14963 wxString *arg2 = 0 ;
14964 bool temp2 = false ;
14965 PyObject * obj0 = 0 ;
14966 PyObject * obj1 = 0 ;
14967 char *kwnames[] = {
14968 (char *) "self",(char *) "s", NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 arg2 = wxString_in_helper(obj1);
14976 if (arg2 == NULL) SWIG_fail;
14977 temp2 = true;
14978 }
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 (arg1)->SetString((wxString const &)*arg2);
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 Py_INCREF(Py_None); resultobj = Py_None;
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 return resultobj;
14992 fail:
14993 {
14994 if (temp2)
14995 delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj;
15003 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15004 wxString result;
15005 PyObject * obj0 = 0 ;
15006 char *kwnames[] = {
15007 (char *) "self", NULL
15008 };
15009
15010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15012 if (SWIG_arg_fail(1)) SWIG_fail;
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = ((wxCommandEvent const *)arg1)->GetString();
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 {
15021 #if wxUSE_UNICODE
15022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15023 #else
15024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15025 #endif
15026 }
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15036 bool result;
15037 PyObject * obj0 = 0 ;
15038 char *kwnames[] = {
15039 (char *) "self", NULL
15040 };
15041
15042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15044 if (SWIG_arg_fail(1)) SWIG_fail;
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 {
15053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15054 }
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj;
15063 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15064 bool result;
15065 PyObject * obj0 = 0 ;
15066 char *kwnames[] = {
15067 (char *) "self", NULL
15068 };
15069
15070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15072 if (SWIG_arg_fail(1)) SWIG_fail;
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 {
15081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15082 }
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15090 PyObject *resultobj;
15091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15092 long arg2 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self",(char *) "extraLong", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 {
15103 arg2 = (long)(SWIG_As_long(obj1));
15104 if (SWIG_arg_fail(2)) SWIG_fail;
15105 }
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 (arg1)->SetExtraLong(arg2);
15109
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 Py_INCREF(Py_None); resultobj = Py_None;
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj;
15122 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15123 long result;
15124 PyObject * obj0 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self", NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(1)) SWIG_fail;
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 {
15140 resultobj = SWIG_From_long((long)(result));
15141 }
15142 return resultobj;
15143 fail:
15144 return NULL;
15145 }
15146
15147
15148 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15149 PyObject *resultobj;
15150 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15151 int arg2 ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "i", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 {
15162 arg2 = (int)(SWIG_As_int(obj1));
15163 if (SWIG_arg_fail(2)) SWIG_fail;
15164 }
15165 {
15166 PyThreadState* __tstate = wxPyBeginAllowThreads();
15167 (arg1)->SetInt(arg2);
15168
15169 wxPyEndAllowThreads(__tstate);
15170 if (PyErr_Occurred()) SWIG_fail;
15171 }
15172 Py_INCREF(Py_None); resultobj = Py_None;
15173 return resultobj;
15174 fail:
15175 return NULL;
15176 }
15177
15178
15179 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15180 PyObject *resultobj;
15181 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15182 long result;
15183 PyObject * obj0 = 0 ;
15184 char *kwnames[] = {
15185 (char *) "self", NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15190 if (SWIG_arg_fail(1)) SWIG_fail;
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15194
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 {
15199 resultobj = SWIG_From_long((long)(result));
15200 }
15201 return resultobj;
15202 fail:
15203 return NULL;
15204 }
15205
15206
15207 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15208 PyObject *resultobj;
15209 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15210 wxEvent *result;
15211 PyObject * obj0 = 0 ;
15212 char *kwnames[] = {
15213 (char *) "self", NULL
15214 };
15215
15216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15218 if (SWIG_arg_fail(1)) SWIG_fail;
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15222
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15227 return resultobj;
15228 fail:
15229 return NULL;
15230 }
15231
15232
15233 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15234 PyObject *obj;
15235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15236 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15237 Py_INCREF(obj);
15238 return Py_BuildValue((char *)"");
15239 }
15240 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15243 int arg2 = (int) 0 ;
15244 wxNotifyEvent *result;
15245 PyObject * obj0 = 0 ;
15246 PyObject * obj1 = 0 ;
15247 char *kwnames[] = {
15248 (char *) "commandType",(char *) "winid", NULL
15249 };
15250
15251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15252 if (obj0) {
15253 {
15254 arg1 = (wxEventType)(SWIG_As_int(obj0));
15255 if (SWIG_arg_fail(1)) SWIG_fail;
15256 }
15257 }
15258 if (obj1) {
15259 {
15260 arg2 = (int)(SWIG_As_int(obj1));
15261 if (SWIG_arg_fail(2)) SWIG_fail;
15262 }
15263 }
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15267
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15281 PyObject * obj0 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 (arg1)->Veto();
15292
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 Py_INCREF(Py_None); resultobj = Py_None;
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15306 PyObject * obj0 = 0 ;
15307 char *kwnames[] = {
15308 (char *) "self", NULL
15309 };
15310
15311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15313 if (SWIG_arg_fail(1)) SWIG_fail;
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 (arg1)->Allow();
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 Py_INCREF(Py_None); resultobj = Py_None;
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15329 PyObject *resultobj;
15330 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15331 bool result;
15332 PyObject * obj0 = 0 ;
15333 char *kwnames[] = {
15334 (char *) "self", NULL
15335 };
15336
15337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15339 if (SWIG_arg_fail(1)) SWIG_fail;
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 result = (bool)(arg1)->IsAllowed();
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 {
15348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15349 }
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15357 PyObject *obj;
15358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15359 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15360 Py_INCREF(obj);
15361 return Py_BuildValue((char *)"");
15362 }
15363 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj;
15365 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15366 int arg2 = (int) 0 ;
15367 int arg3 = (int) 0 ;
15368 int arg4 = (int) 0 ;
15369 wxScrollEvent *result;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 PyObject * obj2 = 0 ;
15373 PyObject * obj3 = 0 ;
15374 char *kwnames[] = {
15375 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15376 };
15377
15378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15379 if (obj0) {
15380 {
15381 arg1 = (wxEventType)(SWIG_As_int(obj0));
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 }
15384 }
15385 if (obj1) {
15386 {
15387 arg2 = (int)(SWIG_As_int(obj1));
15388 if (SWIG_arg_fail(2)) SWIG_fail;
15389 }
15390 }
15391 if (obj2) {
15392 {
15393 arg3 = (int)(SWIG_As_int(obj2));
15394 if (SWIG_arg_fail(3)) SWIG_fail;
15395 }
15396 }
15397 if (obj3) {
15398 {
15399 arg4 = (int)(SWIG_As_int(obj3));
15400 if (SWIG_arg_fail(4)) SWIG_fail;
15401 }
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15420 int result;
15421 PyObject * obj0 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15432
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 {
15437 resultobj = SWIG_From_int((int)(result));
15438 }
15439 return resultobj;
15440 fail:
15441 return NULL;
15442 }
15443
15444
15445 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15446 PyObject *resultobj;
15447 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15448 int result;
15449 PyObject * obj0 = 0 ;
15450 char *kwnames[] = {
15451 (char *) "self", NULL
15452 };
15453
15454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15456 if (SWIG_arg_fail(1)) SWIG_fail;
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15460
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 {
15465 resultobj = SWIG_From_int((int)(result));
15466 }
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15474 PyObject *resultobj;
15475 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15476 int arg2 ;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 char *kwnames[] = {
15480 (char *) "self",(char *) "orient", NULL
15481 };
15482
15483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 {
15487 arg2 = (int)(SWIG_As_int(obj1));
15488 if (SWIG_arg_fail(2)) SWIG_fail;
15489 }
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 (arg1)->SetOrientation(arg2);
15493
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 Py_INCREF(Py_None); resultobj = Py_None;
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj;
15506 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15507 int arg2 ;
15508 PyObject * obj0 = 0 ;
15509 PyObject * obj1 = 0 ;
15510 char *kwnames[] = {
15511 (char *) "self",(char *) "pos", NULL
15512 };
15513
15514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15516 if (SWIG_arg_fail(1)) SWIG_fail;
15517 {
15518 arg2 = (int)(SWIG_As_int(obj1));
15519 if (SWIG_arg_fail(2)) SWIG_fail;
15520 }
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 (arg1)->SetPosition(arg2);
15524
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 Py_INCREF(Py_None); resultobj = Py_None;
15529 return resultobj;
15530 fail:
15531 return NULL;
15532 }
15533
15534
15535 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15536 PyObject *obj;
15537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15538 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15539 Py_INCREF(obj);
15540 return Py_BuildValue((char *)"");
15541 }
15542 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15545 int arg2 = (int) 0 ;
15546 int arg3 = (int) 0 ;
15547 wxScrollWinEvent *result;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 PyObject * obj2 = 0 ;
15551 char *kwnames[] = {
15552 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15553 };
15554
15555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15556 if (obj0) {
15557 {
15558 arg1 = (wxEventType)(SWIG_As_int(obj0));
15559 if (SWIG_arg_fail(1)) SWIG_fail;
15560 }
15561 }
15562 if (obj1) {
15563 {
15564 arg2 = (int)(SWIG_As_int(obj1));
15565 if (SWIG_arg_fail(2)) SWIG_fail;
15566 }
15567 }
15568 if (obj2) {
15569 {
15570 arg3 = (int)(SWIG_As_int(obj2));
15571 if (SWIG_arg_fail(3)) SWIG_fail;
15572 }
15573 }
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj;
15590 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15591 int result;
15592 PyObject * obj0 = 0 ;
15593 char *kwnames[] = {
15594 (char *) "self", NULL
15595 };
15596
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15603
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 {
15608 resultobj = SWIG_From_int((int)(result));
15609 }
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15619 int result;
15620 PyObject * obj0 = 0 ;
15621 char *kwnames[] = {
15622 (char *) "self", NULL
15623 };
15624
15625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15647 int arg2 ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 char *kwnames[] = {
15651 (char *) "self",(char *) "orient", NULL
15652 };
15653
15654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15656 if (SWIG_arg_fail(1)) SWIG_fail;
15657 {
15658 arg2 = (int)(SWIG_As_int(obj1));
15659 if (SWIG_arg_fail(2)) SWIG_fail;
15660 }
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 (arg1)->SetOrientation(arg2);
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 Py_INCREF(Py_None); resultobj = Py_None;
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj;
15677 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15678 int arg2 ;
15679 PyObject * obj0 = 0 ;
15680 PyObject * obj1 = 0 ;
15681 char *kwnames[] = {
15682 (char *) "self",(char *) "pos", NULL
15683 };
15684
15685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15687 if (SWIG_arg_fail(1)) SWIG_fail;
15688 {
15689 arg2 = (int)(SWIG_As_int(obj1));
15690 if (SWIG_arg_fail(2)) SWIG_fail;
15691 }
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 (arg1)->SetPosition(arg2);
15695
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 Py_INCREF(Py_None); resultobj = Py_None;
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15707 PyObject *obj;
15708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15709 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15710 Py_INCREF(obj);
15711 return Py_BuildValue((char *)"");
15712 }
15713 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj;
15715 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15716 wxMouseEvent *result;
15717 PyObject * obj0 = 0 ;
15718 char *kwnames[] = {
15719 (char *) "mouseType", NULL
15720 };
15721
15722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15723 if (obj0) {
15724 {
15725 arg1 = (wxEventType)(SWIG_As_int(obj0));
15726 if (SWIG_arg_fail(1)) SWIG_fail;
15727 }
15728 }
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15732
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 {
15737 resultobj = wxPyMake_wxObject(result, 1);
15738 }
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj;
15747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15748 bool result;
15749 PyObject * obj0 = 0 ;
15750 char *kwnames[] = {
15751 (char *) "self", NULL
15752 };
15753
15754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15756 if (SWIG_arg_fail(1)) SWIG_fail;
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15760
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15766 }
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15776 int arg2 = (int) wxMOUSE_BTN_ANY ;
15777 bool result;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 char *kwnames[] = {
15781 (char *) "self",(char *) "but", NULL
15782 };
15783
15784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15786 if (SWIG_arg_fail(1)) SWIG_fail;
15787 if (obj1) {
15788 {
15789 arg2 = (int)(SWIG_As_int(obj1));
15790 if (SWIG_arg_fail(2)) SWIG_fail;
15791 }
15792 }
15793 {
15794 PyThreadState* __tstate = wxPyBeginAllowThreads();
15795 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15796
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 {
15801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15802 }
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj;
15811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15812 int arg2 = (int) wxMOUSE_BTN_ANY ;
15813 bool result;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char *kwnames[] = {
15817 (char *) "self",(char *) "but", NULL
15818 };
15819
15820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15822 if (SWIG_arg_fail(1)) SWIG_fail;
15823 if (obj1) {
15824 {
15825 arg2 = (int)(SWIG_As_int(obj1));
15826 if (SWIG_arg_fail(2)) SWIG_fail;
15827 }
15828 }
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15838 }
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj;
15847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15848 int arg2 = (int) wxMOUSE_BTN_ANY ;
15849 bool result;
15850 PyObject * obj0 = 0 ;
15851 PyObject * obj1 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self",(char *) "but", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 if (obj1) {
15860 {
15861 arg2 = (int)(SWIG_As_int(obj1));
15862 if (SWIG_arg_fail(2)) SWIG_fail;
15863 }
15864 }
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15868
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 {
15873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15874 }
15875 return resultobj;
15876 fail:
15877 return NULL;
15878 }
15879
15880
15881 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj;
15883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15884 int arg2 ;
15885 bool result;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 char *kwnames[] = {
15889 (char *) "self",(char *) "but", NULL
15890 };
15891
15892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15894 if (SWIG_arg_fail(1)) SWIG_fail;
15895 {
15896 arg2 = (int)(SWIG_As_int(obj1));
15897 if (SWIG_arg_fail(2)) SWIG_fail;
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 {
15907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15908 }
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj;
15917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15918 int arg2 ;
15919 bool result;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char *kwnames[] = {
15923 (char *) "self",(char *) "but", NULL
15924 };
15925
15926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15928 if (SWIG_arg_fail(1)) SWIG_fail;
15929 {
15930 arg2 = (int)(SWIG_As_int(obj1));
15931 if (SWIG_arg_fail(2)) SWIG_fail;
15932 }
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15936
15937 wxPyEndAllowThreads(__tstate);
15938 if (PyErr_Occurred()) SWIG_fail;
15939 }
15940 {
15941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15942 }
15943 return resultobj;
15944 fail:
15945 return NULL;
15946 }
15947
15948
15949 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15950 PyObject *resultobj;
15951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15952 int result;
15953 PyObject * obj0 = 0 ;
15954 char *kwnames[] = {
15955 (char *) "self", NULL
15956 };
15957
15958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15960 if (SWIG_arg_fail(1)) SWIG_fail;
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15964
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 {
15969 resultobj = SWIG_From_int((int)(result));
15970 }
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15978 PyObject *resultobj;
15979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15980 bool result;
15981 PyObject * obj0 = 0 ;
15982 char *kwnames[] = {
15983 (char *) "self", NULL
15984 };
15985
15986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15988 if (SWIG_arg_fail(1)) SWIG_fail;
15989 {
15990 PyThreadState* __tstate = wxPyBeginAllowThreads();
15991 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15992
15993 wxPyEndAllowThreads(__tstate);
15994 if (PyErr_Occurred()) SWIG_fail;
15995 }
15996 {
15997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15998 }
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj;
16007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16008 bool result;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16020
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 {
16025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16026 }
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj;
16035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16036 bool result;
16037 PyObject * obj0 = 0 ;
16038 char *kwnames[] = {
16039 (char *) "self", NULL
16040 };
16041
16042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16044 if (SWIG_arg_fail(1)) SWIG_fail;
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16048
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 {
16053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16054 }
16055 return resultobj;
16056 fail:
16057 return NULL;
16058 }
16059
16060
16061 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16062 PyObject *resultobj;
16063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16064 bool result;
16065 PyObject * obj0 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 {
16081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16082 }
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj;
16091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16092 bool result;
16093 PyObject * obj0 = 0 ;
16094 char *kwnames[] = {
16095 (char *) "self", NULL
16096 };
16097
16098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16100 if (SWIG_arg_fail(1)) SWIG_fail;
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16104
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 {
16109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16110 }
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj;
16119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16120 bool result;
16121 PyObject * obj0 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16132
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 {
16137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16138 }
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16148 bool result;
16149 PyObject * obj0 = 0 ;
16150 char *kwnames[] = {
16151 (char *) "self", NULL
16152 };
16153
16154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16156 if (SWIG_arg_fail(1)) SWIG_fail;
16157 {
16158 PyThreadState* __tstate = wxPyBeginAllowThreads();
16159 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16160
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 {
16165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16166 }
16167 return resultobj;
16168 fail:
16169 return NULL;
16170 }
16171
16172
16173 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16174 PyObject *resultobj;
16175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16176 bool result;
16177 PyObject * obj0 = 0 ;
16178 char *kwnames[] = {
16179 (char *) "self", NULL
16180 };
16181
16182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16184 if (SWIG_arg_fail(1)) SWIG_fail;
16185 {
16186 PyThreadState* __tstate = wxPyBeginAllowThreads();
16187 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16188
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 {
16193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16194 }
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj;
16203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16204 bool result;
16205 PyObject * obj0 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "self", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16216
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 {
16221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16222 }
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj;
16231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16232 bool result;
16233 PyObject * obj0 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "self", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16240 if (SWIG_arg_fail(1)) SWIG_fail;
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16244
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 {
16249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16250 }
16251 return resultobj;
16252 fail:
16253 return NULL;
16254 }
16255
16256
16257 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16258 PyObject *resultobj;
16259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16260 bool result;
16261 PyObject * obj0 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16272
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 {
16277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16278 }
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj;
16287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16288 bool result;
16289 PyObject * obj0 = 0 ;
16290 char *kwnames[] = {
16291 (char *) "self", NULL
16292 };
16293
16294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16296 if (SWIG_arg_fail(1)) SWIG_fail;
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16300
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16306 }
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16314 PyObject *resultobj;
16315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16316 bool result;
16317 PyObject * obj0 = 0 ;
16318 char *kwnames[] = {
16319 (char *) "self", NULL
16320 };
16321
16322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16324 if (SWIG_arg_fail(1)) SWIG_fail;
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 {
16333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj;
16343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16344 bool result;
16345 PyObject * obj0 = 0 ;
16346 char *kwnames[] = {
16347 (char *) "self", NULL
16348 };
16349
16350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16352 if (SWIG_arg_fail(1)) SWIG_fail;
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16356
16357 wxPyEndAllowThreads(__tstate);
16358 if (PyErr_Occurred()) SWIG_fail;
16359 }
16360 {
16361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16362 }
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj;
16371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16372 bool result;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (bool)(arg1)->LeftIsDown();
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16390 }
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16400 bool result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (bool)(arg1)->MiddleIsDown();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj;
16427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16428 bool result;
16429 PyObject * obj0 = 0 ;
16430 char *kwnames[] = {
16431 (char *) "self", NULL
16432 };
16433
16434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16436 if (SWIG_arg_fail(1)) SWIG_fail;
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (bool)(arg1)->RightIsDown();
16440
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 {
16445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16446 }
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj;
16455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16456 bool result;
16457 PyObject * obj0 = 0 ;
16458 char *kwnames[] = {
16459 (char *) "self", NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16464 if (SWIG_arg_fail(1)) SWIG_fail;
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16468
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 {
16473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16474 }
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj;
16483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16484 bool result;
16485 PyObject * obj0 = 0 ;
16486 char *kwnames[] = {
16487 (char *) "self", NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16492 if (SWIG_arg_fail(1)) SWIG_fail;
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16496
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16502 }
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16510 PyObject *resultobj;
16511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16512 bool result;
16513 PyObject * obj0 = 0 ;
16514 char *kwnames[] = {
16515 (char *) "self", NULL
16516 };
16517
16518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16520 if (SWIG_arg_fail(1)) SWIG_fail;
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 {
16529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16530 }
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj;
16539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16540 bool result;
16541 PyObject * obj0 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16558 }
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj;
16567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16568 wxPoint result;
16569 PyObject * obj0 = 0 ;
16570 char *kwnames[] = {
16571 (char *) "self", NULL
16572 };
16573
16574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16576 if (SWIG_arg_fail(1)) SWIG_fail;
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (arg1)->GetPosition();
16580
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 wxPoint * resultptr;
16586 resultptr = new wxPoint((wxPoint &)(result));
16587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16588 }
16589 return resultobj;
16590 fail:
16591 return NULL;
16592 }
16593
16594
16595 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16596 PyObject *resultobj;
16597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16598 long *arg2 = (long *) 0 ;
16599 long *arg3 = (long *) 0 ;
16600 long temp2 ;
16601 int res2 = 0 ;
16602 long temp3 ;
16603 int res3 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 char *kwnames[] = {
16606 (char *) "self", NULL
16607 };
16608
16609 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16610 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16613 if (SWIG_arg_fail(1)) SWIG_fail;
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 (arg1)->GetPosition(arg2,arg3);
16617
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 Py_INCREF(Py_None); resultobj = Py_None;
16622 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16623 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16624 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16625 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16635 wxDC *arg2 = 0 ;
16636 wxPoint result;
16637 PyObject * obj0 = 0 ;
16638 PyObject * obj1 = 0 ;
16639 char *kwnames[] = {
16640 (char *) "self",(char *) "dc", NULL
16641 };
16642
16643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16645 if (SWIG_arg_fail(1)) SWIG_fail;
16646 {
16647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16648 if (SWIG_arg_fail(2)) SWIG_fail;
16649 if (arg2 == NULL) {
16650 SWIG_null_ref("wxDC");
16651 }
16652 if (SWIG_arg_fail(2)) SWIG_fail;
16653 }
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16657
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 {
16662 wxPoint * resultptr;
16663 resultptr = new wxPoint((wxPoint &)(result));
16664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj;
16674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16675 int result;
16676 PyObject * obj0 = 0 ;
16677 char *kwnames[] = {
16678 (char *) "self", NULL
16679 };
16680
16681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16683 if (SWIG_arg_fail(1)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = (int)((wxMouseEvent const *)arg1)->GetX();
16687
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 {
16692 resultobj = SWIG_From_int((int)(result));
16693 }
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj;
16702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16703 int result;
16704 PyObject * obj0 = 0 ;
16705 char *kwnames[] = {
16706 (char *) "self", NULL
16707 };
16708
16709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16711 if (SWIG_arg_fail(1)) SWIG_fail;
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = (int)((wxMouseEvent const *)arg1)->GetY();
16715
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 {
16720 resultobj = SWIG_From_int((int)(result));
16721 }
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj;
16730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16731 int result;
16732 PyObject * obj0 = 0 ;
16733 char *kwnames[] = {
16734 (char *) "self", NULL
16735 };
16736
16737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16739 if (SWIG_arg_fail(1)) SWIG_fail;
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 {
16748 resultobj = SWIG_From_int((int)(result));
16749 }
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16759 int result;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 {
16776 resultobj = SWIG_From_int((int)(result));
16777 }
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16787 int result;
16788 PyObject * obj0 = 0 ;
16789 char *kwnames[] = {
16790 (char *) "self", NULL
16791 };
16792
16793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16795 if (SWIG_arg_fail(1)) SWIG_fail;
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16799
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 {
16804 resultobj = SWIG_From_int((int)(result));
16805 }
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj;
16814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16815 bool result;
16816 PyObject * obj0 = 0 ;
16817 char *kwnames[] = {
16818 (char *) "self", NULL
16819 };
16820
16821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16823 if (SWIG_arg_fail(1)) SWIG_fail;
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16827
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16843 int arg2 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 char *kwnames[] = {
16847 (char *) "self",(char *) "m_x", NULL
16848 };
16849
16850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16852 if (SWIG_arg_fail(1)) SWIG_fail;
16853 {
16854 arg2 = (int)(SWIG_As_int(obj1));
16855 if (SWIG_arg_fail(2)) SWIG_fail;
16856 }
16857 if (arg1) (arg1)->m_x = arg2;
16858
16859 Py_INCREF(Py_None); resultobj = Py_None;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16869 int result;
16870 PyObject * obj0 = 0 ;
16871 char *kwnames[] = {
16872 (char *) "self", NULL
16873 };
16874
16875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 result = (int) ((arg1)->m_x);
16879
16880 {
16881 resultobj = SWIG_From_int((int)(result));
16882 }
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16890 PyObject *resultobj;
16891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16892 int arg2 ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "self",(char *) "m_y", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 {
16903 arg2 = (int)(SWIG_As_int(obj1));
16904 if (SWIG_arg_fail(2)) SWIG_fail;
16905 }
16906 if (arg1) (arg1)->m_y = arg2;
16907
16908 Py_INCREF(Py_None); resultobj = Py_None;
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj;
16917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16918 int result;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 result = (int) ((arg1)->m_y);
16928
16929 {
16930 resultobj = SWIG_From_int((int)(result));
16931 }
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16939 PyObject *resultobj;
16940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16941 bool arg2 ;
16942 PyObject * obj0 = 0 ;
16943 PyObject * obj1 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "self",(char *) "m_leftDown", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 arg2 = (bool)(SWIG_As_bool(obj1));
16953 if (SWIG_arg_fail(2)) SWIG_fail;
16954 }
16955 if (arg1) (arg1)->m_leftDown = arg2;
16956
16957 Py_INCREF(Py_None); resultobj = Py_None;
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj;
16966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16967 bool result;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "self", NULL
16971 };
16972
16973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16975 if (SWIG_arg_fail(1)) SWIG_fail;
16976 result = (bool) ((arg1)->m_leftDown);
16977
16978 {
16979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16980 }
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16990 bool arg2 ;
16991 PyObject * obj0 = 0 ;
16992 PyObject * obj1 = 0 ;
16993 char *kwnames[] = {
16994 (char *) "self",(char *) "m_middleDown", NULL
16995 };
16996
16997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16999 if (SWIG_arg_fail(1)) SWIG_fail;
17000 {
17001 arg2 = (bool)(SWIG_As_bool(obj1));
17002 if (SWIG_arg_fail(2)) SWIG_fail;
17003 }
17004 if (arg1) (arg1)->m_middleDown = arg2;
17005
17006 Py_INCREF(Py_None); resultobj = Py_None;
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17016 bool result;
17017 PyObject * obj0 = 0 ;
17018 char *kwnames[] = {
17019 (char *) "self", NULL
17020 };
17021
17022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17024 if (SWIG_arg_fail(1)) SWIG_fail;
17025 result = (bool) ((arg1)->m_middleDown);
17026
17027 {
17028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17029 }
17030 return resultobj;
17031 fail:
17032 return NULL;
17033 }
17034
17035
17036 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj;
17038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17039 bool arg2 ;
17040 PyObject * obj0 = 0 ;
17041 PyObject * obj1 = 0 ;
17042 char *kwnames[] = {
17043 (char *) "self",(char *) "m_rightDown", NULL
17044 };
17045
17046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17048 if (SWIG_arg_fail(1)) SWIG_fail;
17049 {
17050 arg2 = (bool)(SWIG_As_bool(obj1));
17051 if (SWIG_arg_fail(2)) SWIG_fail;
17052 }
17053 if (arg1) (arg1)->m_rightDown = arg2;
17054
17055 Py_INCREF(Py_None); resultobj = Py_None;
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17065 bool result;
17066 PyObject * obj0 = 0 ;
17067 char *kwnames[] = {
17068 (char *) "self", NULL
17069 };
17070
17071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17073 if (SWIG_arg_fail(1)) SWIG_fail;
17074 result = (bool) ((arg1)->m_rightDown);
17075
17076 {
17077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17088 bool arg2 ;
17089 PyObject * obj0 = 0 ;
17090 PyObject * obj1 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self",(char *) "m_controlDown", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 arg2 = (bool)(SWIG_As_bool(obj1));
17100 if (SWIG_arg_fail(2)) SWIG_fail;
17101 }
17102 if (arg1) (arg1)->m_controlDown = arg2;
17103
17104 Py_INCREF(Py_None); resultobj = Py_None;
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj;
17113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17114 bool result;
17115 PyObject * obj0 = 0 ;
17116 char *kwnames[] = {
17117 (char *) "self", NULL
17118 };
17119
17120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17122 if (SWIG_arg_fail(1)) SWIG_fail;
17123 result = (bool) ((arg1)->m_controlDown);
17124
17125 {
17126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17127 }
17128 return resultobj;
17129 fail:
17130 return NULL;
17131 }
17132
17133
17134 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17135 PyObject *resultobj;
17136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17137 bool arg2 ;
17138 PyObject * obj0 = 0 ;
17139 PyObject * obj1 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self",(char *) "m_shiftDown", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 {
17148 arg2 = (bool)(SWIG_As_bool(obj1));
17149 if (SWIG_arg_fail(2)) SWIG_fail;
17150 }
17151 if (arg1) (arg1)->m_shiftDown = arg2;
17152
17153 Py_INCREF(Py_None); resultobj = Py_None;
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17163 bool result;
17164 PyObject * obj0 = 0 ;
17165 char *kwnames[] = {
17166 (char *) "self", NULL
17167 };
17168
17169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 result = (bool) ((arg1)->m_shiftDown);
17173
17174 {
17175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17176 }
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj;
17185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17186 bool arg2 ;
17187 PyObject * obj0 = 0 ;
17188 PyObject * obj1 = 0 ;
17189 char *kwnames[] = {
17190 (char *) "self",(char *) "m_altDown", NULL
17191 };
17192
17193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17195 if (SWIG_arg_fail(1)) SWIG_fail;
17196 {
17197 arg2 = (bool)(SWIG_As_bool(obj1));
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 if (arg1) (arg1)->m_altDown = arg2;
17201
17202 Py_INCREF(Py_None); resultobj = Py_None;
17203 return resultobj;
17204 fail:
17205 return NULL;
17206 }
17207
17208
17209 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj;
17211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17212 bool result;
17213 PyObject * obj0 = 0 ;
17214 char *kwnames[] = {
17215 (char *) "self", NULL
17216 };
17217
17218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17220 if (SWIG_arg_fail(1)) SWIG_fail;
17221 result = (bool) ((arg1)->m_altDown);
17222
17223 {
17224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17225 }
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17235 bool arg2 ;
17236 PyObject * obj0 = 0 ;
17237 PyObject * obj1 = 0 ;
17238 char *kwnames[] = {
17239 (char *) "self",(char *) "m_metaDown", NULL
17240 };
17241
17242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17244 if (SWIG_arg_fail(1)) SWIG_fail;
17245 {
17246 arg2 = (bool)(SWIG_As_bool(obj1));
17247 if (SWIG_arg_fail(2)) SWIG_fail;
17248 }
17249 if (arg1) (arg1)->m_metaDown = arg2;
17250
17251 Py_INCREF(Py_None); resultobj = Py_None;
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17261 bool result;
17262 PyObject * obj0 = 0 ;
17263 char *kwnames[] = {
17264 (char *) "self", NULL
17265 };
17266
17267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17269 if (SWIG_arg_fail(1)) SWIG_fail;
17270 result = (bool) ((arg1)->m_metaDown);
17271
17272 {
17273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17274 }
17275 return resultobj;
17276 fail:
17277 return NULL;
17278 }
17279
17280
17281 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj;
17283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17284 int arg2 ;
17285 PyObject * obj0 = 0 ;
17286 PyObject * obj1 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self",(char *) "m_wheelRotation", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(1)) SWIG_fail;
17294 {
17295 arg2 = (int)(SWIG_As_int(obj1));
17296 if (SWIG_arg_fail(2)) SWIG_fail;
17297 }
17298 if (arg1) (arg1)->m_wheelRotation = arg2;
17299
17300 Py_INCREF(Py_None); resultobj = Py_None;
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17310 int result;
17311 PyObject * obj0 = 0 ;
17312 char *kwnames[] = {
17313 (char *) "self", NULL
17314 };
17315
17316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_wheelRotation);
17320
17321 {
17322 resultobj = SWIG_From_int((int)(result));
17323 }
17324 return resultobj;
17325 fail:
17326 return NULL;
17327 }
17328
17329
17330 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17331 PyObject *resultobj;
17332 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17333 int arg2 ;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "m_wheelDelta", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 arg2 = (int)(SWIG_As_int(obj1));
17345 if (SWIG_arg_fail(2)) SWIG_fail;
17346 }
17347 if (arg1) (arg1)->m_wheelDelta = arg2;
17348
17349 Py_INCREF(Py_None); resultobj = Py_None;
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 int result;
17360 PyObject * obj0 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 result = (int) ((arg1)->m_wheelDelta);
17369
17370 {
17371 resultobj = SWIG_From_int((int)(result));
17372 }
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj;
17381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17382 int arg2 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self",(char *) "m_linesPerAction", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17391 if (SWIG_arg_fail(1)) SWIG_fail;
17392 {
17393 arg2 = (int)(SWIG_As_int(obj1));
17394 if (SWIG_arg_fail(2)) SWIG_fail;
17395 }
17396 if (arg1) (arg1)->m_linesPerAction = arg2;
17397
17398 Py_INCREF(Py_None); resultobj = Py_None;
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17406 PyObject *resultobj;
17407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17408 int result;
17409 PyObject * obj0 = 0 ;
17410 char *kwnames[] = {
17411 (char *) "self", NULL
17412 };
17413
17414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17416 if (SWIG_arg_fail(1)) SWIG_fail;
17417 result = (int) ((arg1)->m_linesPerAction);
17418
17419 {
17420 resultobj = SWIG_From_int((int)(result));
17421 }
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17429 PyObject *obj;
17430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17431 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17432 Py_INCREF(obj);
17433 return Py_BuildValue((char *)"");
17434 }
17435 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17436 PyObject *resultobj;
17437 int arg1 = (int) 0 ;
17438 int arg2 = (int) 0 ;
17439 wxSetCursorEvent *result;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "x",(char *) "y", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17447 if (obj0) {
17448 {
17449 arg1 = (int)(SWIG_As_int(obj0));
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 }
17452 }
17453 if (obj1) {
17454 {
17455 arg2 = (int)(SWIG_As_int(obj1));
17456 if (SWIG_arg_fail(2)) SWIG_fail;
17457 }
17458 }
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17462
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj;
17475 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17476 int result;
17477 PyObject * obj0 = 0 ;
17478 char *kwnames[] = {
17479 (char *) "self", NULL
17480 };
17481
17482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17484 if (SWIG_arg_fail(1)) SWIG_fail;
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17488
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = SWIG_From_int((int)(result));
17494 }
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17504 int result;
17505 PyObject * obj0 = 0 ;
17506 char *kwnames[] = {
17507 (char *) "self", NULL
17508 };
17509
17510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17512 if (SWIG_arg_fail(1)) SWIG_fail;
17513 {
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17516
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 {
17521 resultobj = SWIG_From_int((int)(result));
17522 }
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj;
17531 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17532 wxCursor *arg2 = 0 ;
17533 PyObject * obj0 = 0 ;
17534 PyObject * obj1 = 0 ;
17535 char *kwnames[] = {
17536 (char *) "self",(char *) "cursor", NULL
17537 };
17538
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 if (arg2 == NULL) {
17546 SWIG_null_ref("wxCursor");
17547 }
17548 if (SWIG_arg_fail(2)) SWIG_fail;
17549 }
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 (arg1)->SetCursor((wxCursor const &)*arg2);
17553
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 Py_INCREF(Py_None); resultobj = Py_None;
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17567 wxCursor *result;
17568 PyObject * obj0 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 {
17579 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17580 result = (wxCursor *) &_result_ref;
17581 }
17582
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 {
17587 wxCursor* resultptr = new wxCursor(*result);
17588 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17589 }
17590 return resultobj;
17591 fail:
17592 return NULL;
17593 }
17594
17595
17596 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj;
17598 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17599 bool result;
17600 PyObject * obj0 = 0 ;
17601 char *kwnames[] = {
17602 (char *) "self", NULL
17603 };
17604
17605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17607 if (SWIG_arg_fail(1)) SWIG_fail;
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17611
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 {
17616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17617 }
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17625 PyObject *obj;
17626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17627 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17628 Py_INCREF(obj);
17629 return Py_BuildValue((char *)"");
17630 }
17631 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj;
17633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17634 wxKeyEvent *result;
17635 PyObject * obj0 = 0 ;
17636 char *kwnames[] = {
17637 (char *) "keyType", NULL
17638 };
17639
17640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17641 if (obj0) {
17642 {
17643 arg1 = (wxEventType)(SWIG_As_int(obj0));
17644 if (SWIG_arg_fail(1)) SWIG_fail;
17645 }
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17650
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj;
17663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17664 bool result;
17665 PyObject * obj0 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17676
17677 wxPyEndAllowThreads(__tstate);
17678 if (PyErr_Occurred()) SWIG_fail;
17679 }
17680 {
17681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17682 }
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17690 PyObject *resultobj;
17691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17692 bool result;
17693 PyObject * obj0 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "self", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17704
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 {
17709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17710 }
17711 return resultobj;
17712 fail:
17713 return NULL;
17714 }
17715
17716
17717 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17718 PyObject *resultobj;
17719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17720 bool result;
17721 PyObject * obj0 = 0 ;
17722 char *kwnames[] = {
17723 (char *) "self", NULL
17724 };
17725
17726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17728 if (SWIG_arg_fail(1)) SWIG_fail;
17729 {
17730 PyThreadState* __tstate = wxPyBeginAllowThreads();
17731 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17732
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj;
17747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17748 bool result;
17749 PyObject * obj0 = 0 ;
17750 char *kwnames[] = {
17751 (char *) "self", NULL
17752 };
17753
17754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17756 if (SWIG_arg_fail(1)) SWIG_fail;
17757 {
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17760
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 {
17765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17766 }
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj;
17775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17776 bool result;
17777 PyObject * obj0 = 0 ;
17778 char *kwnames[] = {
17779 (char *) "self", NULL
17780 };
17781
17782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17784 if (SWIG_arg_fail(1)) SWIG_fail;
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17788
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17794 }
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17804 bool result;
17805 PyObject * obj0 = 0 ;
17806 char *kwnames[] = {
17807 (char *) "self", NULL
17808 };
17809
17810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17812 if (SWIG_arg_fail(1)) SWIG_fail;
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 return resultobj;
17824 fail:
17825 return NULL;
17826 }
17827
17828
17829 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17830 PyObject *resultobj;
17831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17832 int result;
17833 PyObject * obj0 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "self", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = SWIG_From_int((int)(result));
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj;
17859 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17860 int result;
17861 PyObject * obj0 = 0 ;
17862 char *kwnames[] = {
17863 (char *) "self", NULL
17864 };
17865
17866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17868 if (SWIG_arg_fail(1)) SWIG_fail;
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17872
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 {
17877 resultobj = SWIG_From_int((int)(result));
17878 }
17879 return resultobj;
17880 fail:
17881 return NULL;
17882 }
17883
17884
17885 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17886 PyObject *resultobj;
17887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17888 unsigned int result;
17889 PyObject * obj0 = 0 ;
17890 char *kwnames[] = {
17891 (char *) "self", NULL
17892 };
17893
17894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17896 if (SWIG_arg_fail(1)) SWIG_fail;
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 {
17905 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17906 }
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj;
17915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17916 unsigned int result;
17917 PyObject * obj0 = 0 ;
17918 char *kwnames[] = {
17919 (char *) "self", NULL
17920 };
17921
17922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17924 if (SWIG_arg_fail(1)) SWIG_fail;
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17928
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17934 }
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj;
17943 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17944 wxPoint result;
17945 PyObject * obj0 = 0 ;
17946 char *kwnames[] = {
17947 (char *) "self", NULL
17948 };
17949
17950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17952 if (SWIG_arg_fail(1)) SWIG_fail;
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (arg1)->GetPosition();
17956
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 {
17961 wxPoint * resultptr;
17962 resultptr = new wxPoint((wxPoint &)(result));
17963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj;
17973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17974 long *arg2 = (long *) 0 ;
17975 long *arg3 = (long *) 0 ;
17976 long temp2 ;
17977 int res2 = 0 ;
17978 long temp3 ;
17979 int res3 = 0 ;
17980 PyObject * obj0 = 0 ;
17981 char *kwnames[] = {
17982 (char *) "self", NULL
17983 };
17984
17985 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17986 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17989 if (SWIG_arg_fail(1)) SWIG_fail;
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 (arg1)->GetPosition(arg2,arg3);
17993
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 Py_INCREF(Py_None); resultobj = Py_None;
17998 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17999 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18000 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18001 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18011 int result;
18012 PyObject * obj0 = 0 ;
18013 char *kwnames[] = {
18014 (char *) "self", NULL
18015 };
18016
18017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (int)((wxKeyEvent const *)arg1)->GetX();
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = SWIG_From_int((int)(result));
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj;
18038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18039 int result;
18040 PyObject * obj0 = 0 ;
18041 char *kwnames[] = {
18042 (char *) "self", NULL
18043 };
18044
18045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18047 if (SWIG_arg_fail(1)) SWIG_fail;
18048 {
18049 PyThreadState* __tstate = wxPyBeginAllowThreads();
18050 result = (int)((wxKeyEvent const *)arg1)->GetY();
18051
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 {
18056 resultobj = SWIG_From_int((int)(result));
18057 }
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18065 PyObject *resultobj;
18066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18067 int arg2 ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 char *kwnames[] = {
18071 (char *) "self",(char *) "m_x", NULL
18072 };
18073
18074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18076 if (SWIG_arg_fail(1)) SWIG_fail;
18077 {
18078 arg2 = (int)(SWIG_As_int(obj1));
18079 if (SWIG_arg_fail(2)) SWIG_fail;
18080 }
18081 if (arg1) (arg1)->m_x = arg2;
18082
18083 Py_INCREF(Py_None); resultobj = Py_None;
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18093 int result;
18094 PyObject * obj0 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 result = (int) ((arg1)->m_x);
18103
18104 {
18105 resultobj = SWIG_From_int((int)(result));
18106 }
18107 return resultobj;
18108 fail:
18109 return NULL;
18110 }
18111
18112
18113 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj;
18115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18116 int arg2 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 char *kwnames[] = {
18120 (char *) "self",(char *) "m_y", NULL
18121 };
18122
18123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18125 if (SWIG_arg_fail(1)) SWIG_fail;
18126 {
18127 arg2 = (int)(SWIG_As_int(obj1));
18128 if (SWIG_arg_fail(2)) SWIG_fail;
18129 }
18130 if (arg1) (arg1)->m_y = arg2;
18131
18132 Py_INCREF(Py_None); resultobj = Py_None;
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18140 PyObject *resultobj;
18141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18142 int result;
18143 PyObject * obj0 = 0 ;
18144 char *kwnames[] = {
18145 (char *) "self", NULL
18146 };
18147
18148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(1)) SWIG_fail;
18151 result = (int) ((arg1)->m_y);
18152
18153 {
18154 resultobj = SWIG_From_int((int)(result));
18155 }
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj;
18164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18165 long arg2 ;
18166 PyObject * obj0 = 0 ;
18167 PyObject * obj1 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self",(char *) "m_keyCode", NULL
18170 };
18171
18172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18174 if (SWIG_arg_fail(1)) SWIG_fail;
18175 {
18176 arg2 = (long)(SWIG_As_long(obj1));
18177 if (SWIG_arg_fail(2)) SWIG_fail;
18178 }
18179 if (arg1) (arg1)->m_keyCode = arg2;
18180
18181 Py_INCREF(Py_None); resultobj = Py_None;
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18189 PyObject *resultobj;
18190 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18191 long result;
18192 PyObject * obj0 = 0 ;
18193 char *kwnames[] = {
18194 (char *) "self", NULL
18195 };
18196
18197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(1)) SWIG_fail;
18200 result = (long) ((arg1)->m_keyCode);
18201
18202 {
18203 resultobj = SWIG_From_long((long)(result));
18204 }
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18212 PyObject *resultobj;
18213 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18214 bool arg2 ;
18215 PyObject * obj0 = 0 ;
18216 PyObject * obj1 = 0 ;
18217 char *kwnames[] = {
18218 (char *) "self",(char *) "m_controlDown", NULL
18219 };
18220
18221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18223 if (SWIG_arg_fail(1)) SWIG_fail;
18224 {
18225 arg2 = (bool)(SWIG_As_bool(obj1));
18226 if (SWIG_arg_fail(2)) SWIG_fail;
18227 }
18228 if (arg1) (arg1)->m_controlDown = arg2;
18229
18230 Py_INCREF(Py_None); resultobj = Py_None;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj;
18239 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18240 bool result;
18241 PyObject * obj0 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 result = (bool) ((arg1)->m_controlDown);
18250
18251 {
18252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18253 }
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj;
18262 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18263 bool arg2 ;
18264 PyObject * obj0 = 0 ;
18265 PyObject * obj1 = 0 ;
18266 char *kwnames[] = {
18267 (char *) "self",(char *) "m_shiftDown", NULL
18268 };
18269
18270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18272 if (SWIG_arg_fail(1)) SWIG_fail;
18273 {
18274 arg2 = (bool)(SWIG_As_bool(obj1));
18275 if (SWIG_arg_fail(2)) SWIG_fail;
18276 }
18277 if (arg1) (arg1)->m_shiftDown = arg2;
18278
18279 Py_INCREF(Py_None); resultobj = Py_None;
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj;
18288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18289 bool result;
18290 PyObject * obj0 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 result = (bool) ((arg1)->m_shiftDown);
18299
18300 {
18301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18302 }
18303 return resultobj;
18304 fail:
18305 return NULL;
18306 }
18307
18308
18309 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18310 PyObject *resultobj;
18311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18312 bool arg2 ;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 char *kwnames[] = {
18316 (char *) "self",(char *) "m_altDown", NULL
18317 };
18318
18319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18321 if (SWIG_arg_fail(1)) SWIG_fail;
18322 {
18323 arg2 = (bool)(SWIG_As_bool(obj1));
18324 if (SWIG_arg_fail(2)) SWIG_fail;
18325 }
18326 if (arg1) (arg1)->m_altDown = arg2;
18327
18328 Py_INCREF(Py_None); resultobj = Py_None;
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18338 bool result;
18339 PyObject * obj0 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "self", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 result = (bool) ((arg1)->m_altDown);
18348
18349 {
18350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18351 }
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18361 bool arg2 ;
18362 PyObject * obj0 = 0 ;
18363 PyObject * obj1 = 0 ;
18364 char *kwnames[] = {
18365 (char *) "self",(char *) "m_metaDown", NULL
18366 };
18367
18368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18370 if (SWIG_arg_fail(1)) SWIG_fail;
18371 {
18372 arg2 = (bool)(SWIG_As_bool(obj1));
18373 if (SWIG_arg_fail(2)) SWIG_fail;
18374 }
18375 if (arg1) (arg1)->m_metaDown = arg2;
18376
18377 Py_INCREF(Py_None); resultobj = Py_None;
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18387 bool result;
18388 PyObject * obj0 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 result = (bool) ((arg1)->m_metaDown);
18397
18398 {
18399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18400 }
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj;
18409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18410 bool arg2 ;
18411 PyObject * obj0 = 0 ;
18412 PyObject * obj1 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "self",(char *) "m_scanCode", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(1)) SWIG_fail;
18420 {
18421 arg2 = (bool)(SWIG_As_bool(obj1));
18422 if (SWIG_arg_fail(2)) SWIG_fail;
18423 }
18424 if (arg1) (arg1)->m_scanCode = arg2;
18425
18426 Py_INCREF(Py_None); resultobj = Py_None;
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj;
18435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18436 bool result;
18437 PyObject * obj0 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 result = (bool) ((arg1)->m_scanCode);
18446
18447 {
18448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18449 }
18450 return resultobj;
18451 fail:
18452 return NULL;
18453 }
18454
18455
18456 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj;
18458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18459 unsigned int arg2 ;
18460 PyObject * obj0 = 0 ;
18461 PyObject * obj1 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self",(char *) "m_rawCode", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18471 if (SWIG_arg_fail(2)) SWIG_fail;
18472 }
18473 if (arg1) (arg1)->m_rawCode = arg2;
18474
18475 Py_INCREF(Py_None); resultobj = Py_None;
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj;
18484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18485 unsigned int result;
18486 PyObject * obj0 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "self", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18493 if (SWIG_arg_fail(1)) SWIG_fail;
18494 result = (unsigned int) ((arg1)->m_rawCode);
18495
18496 {
18497 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18498 }
18499 return resultobj;
18500 fail:
18501 return NULL;
18502 }
18503
18504
18505 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18506 PyObject *resultobj;
18507 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18508 unsigned int arg2 ;
18509 PyObject * obj0 = 0 ;
18510 PyObject * obj1 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self",(char *) "m_rawFlags", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(1)) SWIG_fail;
18518 {
18519 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18520 if (SWIG_arg_fail(2)) SWIG_fail;
18521 }
18522 if (arg1) (arg1)->m_rawFlags = arg2;
18523
18524 Py_INCREF(Py_None); resultobj = Py_None;
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj;
18533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18534 unsigned int result;
18535 PyObject * obj0 = 0 ;
18536 char *kwnames[] = {
18537 (char *) "self", NULL
18538 };
18539
18540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18542 if (SWIG_arg_fail(1)) SWIG_fail;
18543 result = (unsigned int) ((arg1)->m_rawFlags);
18544
18545 {
18546 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18555 PyObject *obj;
18556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18557 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18558 Py_INCREF(obj);
18559 return Py_BuildValue((char *)"");
18560 }
18561 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18562 PyObject *resultobj;
18563 wxSize const &arg1_defvalue = wxDefaultSize ;
18564 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18565 int arg2 = (int) 0 ;
18566 wxSizeEvent *result;
18567 wxSize temp1 ;
18568 PyObject * obj0 = 0 ;
18569 PyObject * obj1 = 0 ;
18570 char *kwnames[] = {
18571 (char *) "sz",(char *) "winid", NULL
18572 };
18573
18574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18575 if (obj0) {
18576 {
18577 arg1 = &temp1;
18578 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18579 }
18580 }
18581 if (obj1) {
18582 {
18583 arg2 = (int)(SWIG_As_int(obj1));
18584 if (SWIG_arg_fail(2)) SWIG_fail;
18585 }
18586 }
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18590
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18604 wxSize result;
18605 PyObject * obj0 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = ((wxSizeEvent const *)arg1)->GetSize();
18616
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 wxSize * resultptr;
18622 resultptr = new wxSize((wxSize &)(result));
18623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18624 }
18625 return resultobj;
18626 fail:
18627 return NULL;
18628 }
18629
18630
18631 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj;
18633 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18634 wxRect result;
18635 PyObject * obj0 = 0 ;
18636 char *kwnames[] = {
18637 (char *) "self", NULL
18638 };
18639
18640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18642 if (SWIG_arg_fail(1)) SWIG_fail;
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = ((wxSizeEvent const *)arg1)->GetRect();
18646
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 {
18651 wxRect * resultptr;
18652 resultptr = new wxRect((wxRect &)(result));
18653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18654 }
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18662 PyObject *resultobj;
18663 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18664 wxRect arg2 ;
18665 PyObject * obj0 = 0 ;
18666 PyObject * obj1 = 0 ;
18667 char *kwnames[] = {
18668 (char *) "self",(char *) "rect", NULL
18669 };
18670
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 {
18675 wxRect * argp;
18676 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18677 if (SWIG_arg_fail(2)) SWIG_fail;
18678 if (argp == NULL) {
18679 SWIG_null_ref("wxRect");
18680 }
18681 if (SWIG_arg_fail(2)) SWIG_fail;
18682 arg2 = *argp;
18683 }
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 (arg1)->SetRect(arg2);
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 Py_INCREF(Py_None); resultobj = Py_None;
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18699 PyObject *resultobj;
18700 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18701 wxSize arg2 ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 char *kwnames[] = {
18705 (char *) "self",(char *) "size", NULL
18706 };
18707
18708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18710 if (SWIG_arg_fail(1)) SWIG_fail;
18711 {
18712 wxSize * argp;
18713 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 if (argp == NULL) {
18716 SWIG_null_ref("wxSize");
18717 }
18718 if (SWIG_arg_fail(2)) SWIG_fail;
18719 arg2 = *argp;
18720 }
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 wxSizeEvent_SetSize(arg1,arg2);
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 Py_INCREF(Py_None); resultobj = Py_None;
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj;
18737 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18738 wxSize *arg2 = (wxSize *) 0 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "m_size", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18749 if (SWIG_arg_fail(2)) SWIG_fail;
18750 if (arg1) (arg1)->m_size = *arg2;
18751
18752 Py_INCREF(Py_None); resultobj = Py_None;
18753 return resultobj;
18754 fail:
18755 return NULL;
18756 }
18757
18758
18759 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj;
18761 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18762 wxSize *result;
18763 PyObject * obj0 = 0 ;
18764 char *kwnames[] = {
18765 (char *) "self", NULL
18766 };
18767
18768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18770 if (SWIG_arg_fail(1)) SWIG_fail;
18771 result = (wxSize *)& ((arg1)->m_size);
18772
18773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18774 return resultobj;
18775 fail:
18776 return NULL;
18777 }
18778
18779
18780 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18781 PyObject *resultobj;
18782 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18783 wxRect *arg2 = (wxRect *) 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self",(char *) "m_rect", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18794 if (SWIG_arg_fail(2)) SWIG_fail;
18795 if (arg1) (arg1)->m_rect = *arg2;
18796
18797 Py_INCREF(Py_None); resultobj = Py_None;
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj;
18806 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18807 wxRect *result;
18808 PyObject * obj0 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "self", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18815 if (SWIG_arg_fail(1)) SWIG_fail;
18816 result = (wxRect *)& ((arg1)->m_rect);
18817
18818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18826 PyObject *obj;
18827 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18828 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18829 Py_INCREF(obj);
18830 return Py_BuildValue((char *)"");
18831 }
18832 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj;
18834 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18835 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18836 int arg2 = (int) 0 ;
18837 wxMoveEvent *result;
18838 wxPoint temp1 ;
18839 PyObject * obj0 = 0 ;
18840 PyObject * obj1 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "pos",(char *) "winid", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18846 if (obj0) {
18847 {
18848 arg1 = &temp1;
18849 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18850 }
18851 }
18852 if (obj1) {
18853 {
18854 arg2 = (int)(SWIG_As_int(obj1));
18855 if (SWIG_arg_fail(2)) SWIG_fail;
18856 }
18857 }
18858 {
18859 PyThreadState* __tstate = wxPyBeginAllowThreads();
18860 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18861
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18875 wxPoint result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 {
18885 PyThreadState* __tstate = wxPyBeginAllowThreads();
18886 result = ((wxMoveEvent const *)arg1)->GetPosition();
18887
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 {
18892 wxPoint * resultptr;
18893 resultptr = new wxPoint((wxPoint &)(result));
18894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18895 }
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj;
18904 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18905 wxRect result;
18906 PyObject * obj0 = 0 ;
18907 char *kwnames[] = {
18908 (char *) "self", NULL
18909 };
18910
18911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18913 if (SWIG_arg_fail(1)) SWIG_fail;
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = ((wxMoveEvent const *)arg1)->GetRect();
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 {
18922 wxRect * resultptr;
18923 resultptr = new wxRect((wxRect &)(result));
18924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18925 }
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18935 wxRect *arg2 = 0 ;
18936 wxRect temp2 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char *kwnames[] = {
18940 (char *) "self",(char *) "rect", NULL
18941 };
18942
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 {
18947 arg2 = &temp2;
18948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18949 }
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 (arg1)->SetRect((wxRect const &)*arg2);
18953
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 Py_INCREF(Py_None); resultobj = Py_None;
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18965 PyObject *resultobj;
18966 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18967 wxPoint *arg2 = 0 ;
18968 wxPoint temp2 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "pos", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 arg2 = &temp2;
18980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18981 }
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 (arg1)->SetPosition((wxPoint const &)*arg2);
18985
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 Py_INCREF(Py_None); resultobj = Py_None;
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
18997 PyObject *obj;
18998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18999 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19000 Py_INCREF(obj);
19001 return Py_BuildValue((char *)"");
19002 }
19003 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 int arg1 = (int) 0 ;
19006 wxPaintEvent *result;
19007 PyObject * obj0 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "Id", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19013 if (obj0) {
19014 {
19015 arg1 = (int)(SWIG_As_int(obj0));
19016 if (SWIG_arg_fail(1)) SWIG_fail;
19017 }
19018 }
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19022
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19034 PyObject *obj;
19035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19036 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19037 Py_INCREF(obj);
19038 return Py_BuildValue((char *)"");
19039 }
19040 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19041 PyObject *resultobj;
19042 int arg1 = (int) 0 ;
19043 wxNcPaintEvent *result;
19044 PyObject * obj0 = 0 ;
19045 char *kwnames[] = {
19046 (char *) "winid", NULL
19047 };
19048
19049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19050 if (obj0) {
19051 {
19052 arg1 = (int)(SWIG_As_int(obj0));
19053 if (SWIG_arg_fail(1)) SWIG_fail;
19054 }
19055 }
19056 {
19057 PyThreadState* __tstate = wxPyBeginAllowThreads();
19058 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19059
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19071 PyObject *obj;
19072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19073 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19074 Py_INCREF(obj);
19075 return Py_BuildValue((char *)"");
19076 }
19077 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj;
19079 int arg1 = (int) 0 ;
19080 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19081 wxEraseEvent *result;
19082 PyObject * obj0 = 0 ;
19083 PyObject * obj1 = 0 ;
19084 char *kwnames[] = {
19085 (char *) "Id",(char *) "dc", NULL
19086 };
19087
19088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19089 if (obj0) {
19090 {
19091 arg1 = (int)(SWIG_As_int(obj0));
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 }
19094 }
19095 if (obj1) {
19096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19097 if (SWIG_arg_fail(2)) SWIG_fail;
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19116 wxDC *result;
19117 PyObject * obj0 = 0 ;
19118 char *kwnames[] = {
19119 (char *) "self", NULL
19120 };
19121
19122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19124 if (SWIG_arg_fail(1)) SWIG_fail;
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19128
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = wxPyMake_wxObject(result, 0);
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19142 PyObject *obj;
19143 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19144 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19145 Py_INCREF(obj);
19146 return Py_BuildValue((char *)"");
19147 }
19148 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19149 PyObject *resultobj;
19150 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19151 int arg2 = (int) 0 ;
19152 wxFocusEvent *result;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char *kwnames[] = {
19156 (char *) "type",(char *) "winid", NULL
19157 };
19158
19159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19160 if (obj0) {
19161 {
19162 arg1 = (wxEventType)(SWIG_As_int(obj0));
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 }
19165 }
19166 if (obj1) {
19167 {
19168 arg2 = (int)(SWIG_As_int(obj1));
19169 if (SWIG_arg_fail(2)) SWIG_fail;
19170 }
19171 }
19172 {
19173 PyThreadState* __tstate = wxPyBeginAllowThreads();
19174 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19175
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19180 return resultobj;
19181 fail:
19182 return NULL;
19183 }
19184
19185
19186 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19187 PyObject *resultobj;
19188 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19189 wxWindow *result;
19190 PyObject * obj0 = 0 ;
19191 char *kwnames[] = {
19192 (char *) "self", NULL
19193 };
19194
19195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19197 if (SWIG_arg_fail(1)) SWIG_fail;
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19201
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 {
19206 resultobj = wxPyMake_wxObject(result, 0);
19207 }
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj;
19216 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19217 wxWindow *arg2 = (wxWindow *) 0 ;
19218 PyObject * obj0 = 0 ;
19219 PyObject * obj1 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "self",(char *) "win", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19228 if (SWIG_arg_fail(2)) SWIG_fail;
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 (arg1)->SetWindow(arg2);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 Py_INCREF(Py_None); resultobj = Py_None;
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19244 PyObject *obj;
19245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19246 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19247 Py_INCREF(obj);
19248 return Py_BuildValue((char *)"");
19249 }
19250 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxWindow *arg1 = (wxWindow *) NULL ;
19253 wxChildFocusEvent *result;
19254 PyObject * obj0 = 0 ;
19255 char *kwnames[] = {
19256 (char *) "win", NULL
19257 };
19258
19259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19260 if (obj0) {
19261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19267
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19281 wxWindow *result;
19282 PyObject * obj0 = 0 ;
19283 char *kwnames[] = {
19284 (char *) "self", NULL
19285 };
19286
19287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19289 if (SWIG_arg_fail(1)) SWIG_fail;
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19293
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 {
19298 resultobj = wxPyMake_wxObject(result, 0);
19299 }
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19307 PyObject *obj;
19308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19309 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19310 Py_INCREF(obj);
19311 return Py_BuildValue((char *)"");
19312 }
19313 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19316 bool arg2 = (bool) true ;
19317 int arg3 = (int) 0 ;
19318 wxActivateEvent *result;
19319 PyObject * obj0 = 0 ;
19320 PyObject * obj1 = 0 ;
19321 PyObject * obj2 = 0 ;
19322 char *kwnames[] = {
19323 (char *) "type",(char *) "active",(char *) "Id", NULL
19324 };
19325
19326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19327 if (obj0) {
19328 {
19329 arg1 = (wxEventType)(SWIG_As_int(obj0));
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 }
19332 }
19333 if (obj1) {
19334 {
19335 arg2 = (bool)(SWIG_As_bool(obj1));
19336 if (SWIG_arg_fail(2)) SWIG_fail;
19337 }
19338 }
19339 if (obj2) {
19340 {
19341 arg3 = (int)(SWIG_As_int(obj2));
19342 if (SWIG_arg_fail(3)) SWIG_fail;
19343 }
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj;
19361 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19362 bool result;
19363 PyObject * obj0 = 0 ;
19364 char *kwnames[] = {
19365 (char *) "self", NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19370 if (SWIG_arg_fail(1)) SWIG_fail;
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19374
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 {
19379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19380 }
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19388 PyObject *obj;
19389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19390 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19391 Py_INCREF(obj);
19392 return Py_BuildValue((char *)"");
19393 }
19394 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 int arg1 = (int) 0 ;
19397 wxInitDialogEvent *result;
19398 PyObject * obj0 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "Id", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19404 if (obj0) {
19405 {
19406 arg1 = (int)(SWIG_As_int(obj0));
19407 if (SWIG_arg_fail(1)) SWIG_fail;
19408 }
19409 }
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19413
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19425 PyObject *obj;
19426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19427 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19428 Py_INCREF(obj);
19429 return Py_BuildValue((char *)"");
19430 }
19431 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19432 PyObject *resultobj;
19433 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19434 int arg2 = (int) 0 ;
19435 wxMenu *arg3 = (wxMenu *) NULL ;
19436 wxMenuEvent *result;
19437 PyObject * obj0 = 0 ;
19438 PyObject * obj1 = 0 ;
19439 PyObject * obj2 = 0 ;
19440 char *kwnames[] = {
19441 (char *) "type",(char *) "winid",(char *) "menu", NULL
19442 };
19443
19444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19445 if (obj0) {
19446 {
19447 arg1 = (wxEventType)(SWIG_As_int(obj0));
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 }
19450 }
19451 if (obj1) {
19452 {
19453 arg2 = (int)(SWIG_As_int(obj1));
19454 if (SWIG_arg_fail(2)) SWIG_fail;
19455 }
19456 }
19457 if (obj2) {
19458 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19459 if (SWIG_arg_fail(3)) SWIG_fail;
19460 }
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19464
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19476 PyObject *resultobj;
19477 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19478 int result;
19479 PyObject * obj0 = 0 ;
19480 char *kwnames[] = {
19481 (char *) "self", NULL
19482 };
19483
19484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 {
19488 PyThreadState* __tstate = wxPyBeginAllowThreads();
19489 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19490
19491 wxPyEndAllowThreads(__tstate);
19492 if (PyErr_Occurred()) SWIG_fail;
19493 }
19494 {
19495 resultobj = SWIG_From_int((int)(result));
19496 }
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19506 bool result;
19507 PyObject * obj0 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "self", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19514 if (SWIG_arg_fail(1)) SWIG_fail;
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 {
19523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19524 }
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19532 PyObject *resultobj;
19533 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19534 wxMenu *result;
19535 PyObject * obj0 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "self", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19542 if (SWIG_arg_fail(1)) SWIG_fail;
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 {
19551 resultobj = wxPyMake_wxObject(result, 0);
19552 }
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19560 PyObject *obj;
19561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19562 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19563 Py_INCREF(obj);
19564 return Py_BuildValue((char *)"");
19565 }
19566 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj;
19568 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19569 int arg2 = (int) 0 ;
19570 wxCloseEvent *result;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 char *kwnames[] = {
19574 (char *) "type",(char *) "winid", NULL
19575 };
19576
19577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19578 if (obj0) {
19579 {
19580 arg1 = (wxEventType)(SWIG_As_int(obj0));
19581 if (SWIG_arg_fail(1)) SWIG_fail;
19582 }
19583 }
19584 if (obj1) {
19585 {
19586 arg2 = (int)(SWIG_As_int(obj1));
19587 if (SWIG_arg_fail(2)) SWIG_fail;
19588 }
19589 }
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19593
19594 wxPyEndAllowThreads(__tstate);
19595 if (PyErr_Occurred()) SWIG_fail;
19596 }
19597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19607 bool arg2 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "self",(char *) "logOff", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19616 if (SWIG_arg_fail(1)) SWIG_fail;
19617 {
19618 arg2 = (bool)(SWIG_As_bool(obj1));
19619 if (SWIG_arg_fail(2)) SWIG_fail;
19620 }
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 (arg1)->SetLoggingOff(arg2);
19624
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 Py_INCREF(Py_None); resultobj = Py_None;
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19636 PyObject *resultobj;
19637 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19638 bool result;
19639 PyObject * obj0 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 PyThreadState* __tstate = wxPyBeginAllowThreads();
19649 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19650
19651 wxPyEndAllowThreads(__tstate);
19652 if (PyErr_Occurred()) SWIG_fail;
19653 }
19654 {
19655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19656 }
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19666 bool arg2 = (bool) true ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "self",(char *) "veto", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 if (obj1) {
19677 {
19678 arg2 = (bool)(SWIG_As_bool(obj1));
19679 if (SWIG_arg_fail(2)) SWIG_fail;
19680 }
19681 }
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 (arg1)->Veto(arg2);
19685
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 Py_INCREF(Py_None); resultobj = Py_None;
19690 return resultobj;
19691 fail:
19692 return NULL;
19693 }
19694
19695
19696 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19697 PyObject *resultobj;
19698 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19699 bool arg2 ;
19700 PyObject * obj0 = 0 ;
19701 PyObject * obj1 = 0 ;
19702 char *kwnames[] = {
19703 (char *) "self",(char *) "canVeto", NULL
19704 };
19705
19706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19708 if (SWIG_arg_fail(1)) SWIG_fail;
19709 {
19710 arg2 = (bool)(SWIG_As_bool(obj1));
19711 if (SWIG_arg_fail(2)) SWIG_fail;
19712 }
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 (arg1)->SetCanVeto(arg2);
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 Py_INCREF(Py_None); resultobj = Py_None;
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19730 bool result;
19731 PyObject * obj0 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "self", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19738 if (SWIG_arg_fail(1)) SWIG_fail;
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19742
19743 wxPyEndAllowThreads(__tstate);
19744 if (PyErr_Occurred()) SWIG_fail;
19745 }
19746 {
19747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19748 }
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj;
19757 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19758 bool result;
19759 PyObject * obj0 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "self", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19766 if (SWIG_arg_fail(1)) SWIG_fail;
19767 {
19768 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19770
19771 wxPyEndAllowThreads(__tstate);
19772 if (PyErr_Occurred()) SWIG_fail;
19773 }
19774 {
19775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19776 }
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19784 PyObject *obj;
19785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19786 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19787 Py_INCREF(obj);
19788 return Py_BuildValue((char *)"");
19789 }
19790 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj;
19792 int arg1 = (int) 0 ;
19793 bool arg2 = (bool) false ;
19794 wxShowEvent *result;
19795 PyObject * obj0 = 0 ;
19796 PyObject * obj1 = 0 ;
19797 char *kwnames[] = {
19798 (char *) "winid",(char *) "show", NULL
19799 };
19800
19801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19802 if (obj0) {
19803 {
19804 arg1 = (int)(SWIG_As_int(obj0));
19805 if (SWIG_arg_fail(1)) SWIG_fail;
19806 }
19807 }
19808 if (obj1) {
19809 {
19810 arg2 = (bool)(SWIG_As_bool(obj1));
19811 if (SWIG_arg_fail(2)) SWIG_fail;
19812 }
19813 }
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19829 PyObject *resultobj;
19830 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19831 bool arg2 ;
19832 PyObject * obj0 = 0 ;
19833 PyObject * obj1 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "self",(char *) "show", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 arg2 = (bool)(SWIG_As_bool(obj1));
19843 if (SWIG_arg_fail(2)) SWIG_fail;
19844 }
19845 {
19846 PyThreadState* __tstate = wxPyBeginAllowThreads();
19847 (arg1)->SetShow(arg2);
19848
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 Py_INCREF(Py_None); resultobj = Py_None;
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj;
19861 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19862 bool result;
19863 PyObject * obj0 = 0 ;
19864 char *kwnames[] = {
19865 (char *) "self", NULL
19866 };
19867
19868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19870 if (SWIG_arg_fail(1)) SWIG_fail;
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 {
19879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19880 }
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19888 PyObject *obj;
19889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19890 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19891 Py_INCREF(obj);
19892 return Py_BuildValue((char *)"");
19893 }
19894 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj;
19896 int arg1 = (int) 0 ;
19897 bool arg2 = (bool) true ;
19898 wxIconizeEvent *result;
19899 PyObject * obj0 = 0 ;
19900 PyObject * obj1 = 0 ;
19901 char *kwnames[] = {
19902 (char *) "id",(char *) "iconized", NULL
19903 };
19904
19905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
19906 if (obj0) {
19907 {
19908 arg1 = (int)(SWIG_As_int(obj0));
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 }
19911 }
19912 if (obj1) {
19913 {
19914 arg2 = (bool)(SWIG_As_bool(obj1));
19915 if (SWIG_arg_fail(2)) SWIG_fail;
19916 }
19917 }
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
19926 return resultobj;
19927 fail:
19928 return NULL;
19929 }
19930
19931
19932 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
19933 PyObject *resultobj;
19934 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
19935 bool result;
19936 PyObject * obj0 = 0 ;
19937 char *kwnames[] = {
19938 (char *) "self", NULL
19939 };
19940
19941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
19942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
19943 if (SWIG_arg_fail(1)) SWIG_fail;
19944 {
19945 PyThreadState* __tstate = wxPyBeginAllowThreads();
19946 result = (bool)(arg1)->Iconized();
19947
19948 wxPyEndAllowThreads(__tstate);
19949 if (PyErr_Occurred()) SWIG_fail;
19950 }
19951 {
19952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19953 }
19954 return resultobj;
19955 fail:
19956 return NULL;
19957 }
19958
19959
19960 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
19961 PyObject *obj;
19962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19963 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
19964 Py_INCREF(obj);
19965 return Py_BuildValue((char *)"");
19966 }
19967 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19968 PyObject *resultobj;
19969 int arg1 = (int) 0 ;
19970 wxMaximizeEvent *result;
19971 PyObject * obj0 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "id", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
19977 if (obj0) {
19978 {
19979 arg1 = (int)(SWIG_As_int(obj0));
19980 if (SWIG_arg_fail(1)) SWIG_fail;
19981 }
19982 }
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
19986
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
19998 PyObject *obj;
19999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20000 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20001 Py_INCREF(obj);
20002 return Py_BuildValue((char *)"");
20003 }
20004 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj;
20006 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20007 wxPoint result;
20008 PyObject * obj0 = 0 ;
20009 char *kwnames[] = {
20010 (char *) "self", NULL
20011 };
20012
20013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20015 if (SWIG_arg_fail(1)) SWIG_fail;
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (arg1)->GetPosition();
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 {
20024 wxPoint * resultptr;
20025 resultptr = new wxPoint((wxPoint &)(result));
20026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20027 }
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20035 PyObject *resultobj;
20036 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20037 int result;
20038 PyObject * obj0 = 0 ;
20039 char *kwnames[] = {
20040 (char *) "self", NULL
20041 };
20042
20043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20045 if (SWIG_arg_fail(1)) SWIG_fail;
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (int)(arg1)->GetNumberOfFiles();
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 {
20054 resultobj = SWIG_From_int((int)(result));
20055 }
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20065 PyObject *result;
20066 PyObject * obj0 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20077
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 resultobj = result;
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20089 PyObject *obj;
20090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20091 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20092 Py_INCREF(obj);
20093 return Py_BuildValue((char *)"");
20094 }
20095 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 int arg1 = (int) 0 ;
20098 wxUpdateUIEvent *result;
20099 PyObject * obj0 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "commandId", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20105 if (obj0) {
20106 {
20107 arg1 = (int)(SWIG_As_int(obj0));
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 }
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20114
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20119 return resultobj;
20120 fail:
20121 return NULL;
20122 }
20123
20124
20125 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20126 PyObject *resultobj;
20127 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20128 bool result;
20129 PyObject * obj0 = 0 ;
20130 char *kwnames[] = {
20131 (char *) "self", NULL
20132 };
20133
20134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20136 if (SWIG_arg_fail(1)) SWIG_fail;
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20140
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20154 PyObject *resultobj;
20155 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20156 bool result;
20157 PyObject * obj0 = 0 ;
20158 char *kwnames[] = {
20159 (char *) "self", NULL
20160 };
20161
20162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20164 if (SWIG_arg_fail(1)) SWIG_fail;
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20168
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 {
20173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20174 }
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20182 PyObject *resultobj;
20183 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20184 wxString result;
20185 PyObject * obj0 = 0 ;
20186 char *kwnames[] = {
20187 (char *) "self", NULL
20188 };
20189
20190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20192 if (SWIG_arg_fail(1)) SWIG_fail;
20193 {
20194 PyThreadState* __tstate = wxPyBeginAllowThreads();
20195 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20196
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 #if wxUSE_UNICODE
20202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20203 #else
20204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20205 #endif
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj;
20215 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20216 bool result;
20217 PyObject * obj0 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 {
20233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20234 }
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj;
20243 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20244 bool result;
20245 PyObject * obj0 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20272 bool result;
20273 PyObject * obj0 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "self", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20280 if (SWIG_arg_fail(1)) SWIG_fail;
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20284
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 {
20289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj;
20299 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20300 bool arg2 ;
20301 PyObject * obj0 = 0 ;
20302 PyObject * obj1 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self",(char *) "check", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 arg2 = (bool)(SWIG_As_bool(obj1));
20312 if (SWIG_arg_fail(2)) SWIG_fail;
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 (arg1)->Check(arg2);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 Py_INCREF(Py_None); resultobj = Py_None;
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20329 PyObject *resultobj;
20330 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20331 bool arg2 ;
20332 PyObject * obj0 = 0 ;
20333 PyObject * obj1 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self",(char *) "enable", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 arg2 = (bool)(SWIG_As_bool(obj1));
20343 if (SWIG_arg_fail(2)) SWIG_fail;
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 (arg1)->Enable(arg2);
20348
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 Py_INCREF(Py_None); resultobj = Py_None;
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj;
20361 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20362 wxString *arg2 = 0 ;
20363 bool temp2 = false ;
20364 PyObject * obj0 = 0 ;
20365 PyObject * obj1 = 0 ;
20366 char *kwnames[] = {
20367 (char *) "self",(char *) "text", NULL
20368 };
20369
20370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(1)) SWIG_fail;
20373 {
20374 arg2 = wxString_in_helper(obj1);
20375 if (arg2 == NULL) SWIG_fail;
20376 temp2 = true;
20377 }
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 (arg1)->SetText((wxString const &)*arg2);
20381
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 Py_INCREF(Py_None); resultobj = Py_None;
20386 {
20387 if (temp2)
20388 delete arg2;
20389 }
20390 return resultobj;
20391 fail:
20392 {
20393 if (temp2)
20394 delete arg2;
20395 }
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 long arg1 ;
20403 PyObject * obj0 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "updateInterval", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20409 {
20410 arg1 = (long)(SWIG_As_long(obj0));
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 }
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 wxUpdateUIEvent::SetUpdateInterval(arg1);
20416
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 Py_INCREF(Py_None); resultobj = Py_None;
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 long result;
20430 char *kwnames[] = {
20431 NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20435 {
20436 PyThreadState* __tstate = wxPyBeginAllowThreads();
20437 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20438
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 {
20443 resultobj = SWIG_From_long((long)(result));
20444 }
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj;
20453 wxWindow *arg1 = (wxWindow *) 0 ;
20454 bool result;
20455 PyObject * obj0 = 0 ;
20456 char *kwnames[] = {
20457 (char *) "win", NULL
20458 };
20459
20460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20462 if (SWIG_arg_fail(1)) SWIG_fail;
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20466
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20480 PyObject *resultobj;
20481 char *kwnames[] = {
20482 NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 wxUpdateUIEvent::ResetUpdateTime();
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 Py_INCREF(Py_None); resultobj = Py_None;
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxUpdateUIMode arg1 ;
20503 PyObject * obj0 = 0 ;
20504 char *kwnames[] = {
20505 (char *) "mode", NULL
20506 };
20507
20508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20509 {
20510 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20511 if (SWIG_arg_fail(1)) SWIG_fail;
20512 }
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20516
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 Py_INCREF(Py_None); resultobj = Py_None;
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj;
20529 wxUpdateUIMode result;
20530 char *kwnames[] = {
20531 NULL
20532 };
20533
20534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 resultobj = SWIG_From_int((result));
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20550 PyObject *obj;
20551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20552 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20553 Py_INCREF(obj);
20554 return Py_BuildValue((char *)"");
20555 }
20556 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxSysColourChangedEvent *result;
20559 char *kwnames[] = {
20560 NULL
20561 };
20562
20563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20567
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20579 PyObject *obj;
20580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20581 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20582 Py_INCREF(obj);
20583 return Py_BuildValue((char *)"");
20584 }
20585 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20586 PyObject *resultobj;
20587 int arg1 = (int) 0 ;
20588 wxWindow *arg2 = (wxWindow *) NULL ;
20589 wxMouseCaptureChangedEvent *result;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 char *kwnames[] = {
20593 (char *) "winid",(char *) "gainedCapture", NULL
20594 };
20595
20596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20597 if (obj0) {
20598 {
20599 arg1 = (int)(SWIG_As_int(obj0));
20600 if (SWIG_arg_fail(1)) SWIG_fail;
20601 }
20602 }
20603 if (obj1) {
20604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20605 if (SWIG_arg_fail(2)) SWIG_fail;
20606 }
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj;
20623 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20624 wxWindow *result;
20625 PyObject * obj0 = 0 ;
20626 char *kwnames[] = {
20627 (char *) "self", NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20632 if (SWIG_arg_fail(1)) SWIG_fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 {
20641 resultobj = wxPyMake_wxObject(result, 0);
20642 }
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20650 PyObject *obj;
20651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20652 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20653 Py_INCREF(obj);
20654 return Py_BuildValue((char *)"");
20655 }
20656 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj;
20658 wxDisplayChangedEvent *result;
20659 char *kwnames[] = {
20660 NULL
20661 };
20662
20663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20667
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20679 PyObject *obj;
20680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20681 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20682 Py_INCREF(obj);
20683 return Py_BuildValue((char *)"");
20684 }
20685 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj;
20687 int arg1 = (int) 0 ;
20688 wxPaletteChangedEvent *result;
20689 PyObject * obj0 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "id", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20695 if (obj0) {
20696 {
20697 arg1 = (int)(SWIG_As_int(obj0));
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 }
20700 }
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20704
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj;
20717 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20718 wxWindow *arg2 = (wxWindow *) 0 ;
20719 PyObject * obj0 = 0 ;
20720 PyObject * obj1 = 0 ;
20721 char *kwnames[] = {
20722 (char *) "self",(char *) "win", NULL
20723 };
20724
20725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20729 if (SWIG_arg_fail(2)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 (arg1)->SetChangedWindow(arg2);
20733
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 Py_INCREF(Py_None); resultobj = Py_None;
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj;
20746 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20747 wxWindow *result;
20748 PyObject * obj0 = 0 ;
20749 char *kwnames[] = {
20750 (char *) "self", NULL
20751 };
20752
20753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20755 if (SWIG_arg_fail(1)) SWIG_fail;
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (wxWindow *)(arg1)->GetChangedWindow();
20759
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 {
20764 resultobj = wxPyMake_wxObject(result, 0);
20765 }
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20773 PyObject *obj;
20774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20775 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20776 Py_INCREF(obj);
20777 return Py_BuildValue((char *)"");
20778 }
20779 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 int arg1 = (int) 0 ;
20782 wxQueryNewPaletteEvent *result;
20783 PyObject * obj0 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "winid", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20798
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20812 bool arg2 ;
20813 PyObject * obj0 = 0 ;
20814 PyObject * obj1 = 0 ;
20815 char *kwnames[] = {
20816 (char *) "self",(char *) "realized", NULL
20817 };
20818
20819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20821 if (SWIG_arg_fail(1)) SWIG_fail;
20822 {
20823 arg2 = (bool)(SWIG_As_bool(obj1));
20824 if (SWIG_arg_fail(2)) SWIG_fail;
20825 }
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 (arg1)->SetPaletteRealized(arg2);
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 Py_INCREF(Py_None); resultobj = Py_None;
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20843 bool result;
20844 PyObject * obj0 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20869 PyObject *obj;
20870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20871 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20872 Py_INCREF(obj);
20873 return Py_BuildValue((char *)"");
20874 }
20875 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 wxNavigationKeyEvent *result;
20878 char *kwnames[] = {
20879 NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20900 bool result;
20901 PyObject * obj0 = 0 ;
20902 char *kwnames[] = {
20903 (char *) "self", NULL
20904 };
20905
20906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
20907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20908 if (SWIG_arg_fail(1)) SWIG_fail;
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20926 PyObject *resultobj;
20927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20928 bool arg2 ;
20929 PyObject * obj0 = 0 ;
20930 PyObject * obj1 = 0 ;
20931 char *kwnames[] = {
20932 (char *) "self",(char *) "forward", NULL
20933 };
20934
20935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
20936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20937 if (SWIG_arg_fail(1)) SWIG_fail;
20938 {
20939 arg2 = (bool)(SWIG_As_bool(obj1));
20940 if (SWIG_arg_fail(2)) SWIG_fail;
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 (arg1)->SetDirection(arg2);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 Py_INCREF(Py_None); resultobj = Py_None;
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20957 PyObject *resultobj;
20958 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20959 bool result;
20960 PyObject * obj0 = 0 ;
20961 char *kwnames[] = {
20962 (char *) "self", NULL
20963 };
20964
20965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
20966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20967 if (SWIG_arg_fail(1)) SWIG_fail;
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20977 }
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20985 PyObject *resultobj;
20986 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20987 bool arg2 ;
20988 PyObject * obj0 = 0 ;
20989 PyObject * obj1 = 0 ;
20990 char *kwnames[] = {
20991 (char *) "self",(char *) "ischange", NULL
20992 };
20993
20994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
20995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20996 if (SWIG_arg_fail(1)) SWIG_fail;
20997 {
20998 arg2 = (bool)(SWIG_As_bool(obj1));
20999 if (SWIG_arg_fail(2)) SWIG_fail;
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 (arg1)->SetWindowChange(arg2);
21004
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 Py_INCREF(Py_None); resultobj = Py_None;
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21018 long arg2 ;
21019 PyObject * obj0 = 0 ;
21020 PyObject * obj1 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self",(char *) "flags", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 arg2 = (long)(SWIG_As_long(obj1));
21030 if (SWIG_arg_fail(2)) SWIG_fail;
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 (arg1)->SetFlags(arg2);
21035
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 Py_INCREF(Py_None); resultobj = Py_None;
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21047 PyObject *resultobj;
21048 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21049 wxWindow *result;
21050 PyObject * obj0 = 0 ;
21051 char *kwnames[] = {
21052 (char *) "self", NULL
21053 };
21054
21055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21057 if (SWIG_arg_fail(1)) SWIG_fail;
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21061
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 resultobj = wxPyMake_wxObject(result, 0);
21067 }
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21075 PyObject *resultobj;
21076 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21077 wxWindow *arg2 = (wxWindow *) 0 ;
21078 PyObject * obj0 = 0 ;
21079 PyObject * obj1 = 0 ;
21080 char *kwnames[] = {
21081 (char *) "self",(char *) "win", NULL
21082 };
21083
21084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21086 if (SWIG_arg_fail(1)) SWIG_fail;
21087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21088 if (SWIG_arg_fail(2)) SWIG_fail;
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 (arg1)->SetCurrentFocus(arg2);
21092
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 Py_INCREF(Py_None); resultobj = Py_None;
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21104 PyObject *obj;
21105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21106 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21107 Py_INCREF(obj);
21108 return Py_BuildValue((char *)"");
21109 }
21110 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21111 PyObject *resultobj;
21112 wxWindow *arg1 = (wxWindow *) NULL ;
21113 wxWindowCreateEvent *result;
21114 PyObject * obj0 = 0 ;
21115 char *kwnames[] = {
21116 (char *) "win", NULL
21117 };
21118
21119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21120 if (obj0) {
21121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21122 if (SWIG_arg_fail(1)) SWIG_fail;
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21139 PyObject *resultobj;
21140 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21141 wxWindow *result;
21142 PyObject * obj0 = 0 ;
21143 char *kwnames[] = {
21144 (char *) "self", NULL
21145 };
21146
21147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21149 if (SWIG_arg_fail(1)) SWIG_fail;
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 {
21158 resultobj = wxPyMake_wxObject(result, 0);
21159 }
21160 return resultobj;
21161 fail:
21162 return NULL;
21163 }
21164
21165
21166 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21167 PyObject *obj;
21168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21169 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21170 Py_INCREF(obj);
21171 return Py_BuildValue((char *)"");
21172 }
21173 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj;
21175 wxWindow *arg1 = (wxWindow *) NULL ;
21176 wxWindowDestroyEvent *result;
21177 PyObject * obj0 = 0 ;
21178 char *kwnames[] = {
21179 (char *) "win", NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21183 if (obj0) {
21184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21185 if (SWIG_arg_fail(1)) SWIG_fail;
21186 }
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21204 wxWindow *result;
21205 PyObject * obj0 = 0 ;
21206 char *kwnames[] = {
21207 (char *) "self", NULL
21208 };
21209
21210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21216
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 {
21221 resultobj = wxPyMake_wxObject(result, 0);
21222 }
21223 return resultobj;
21224 fail:
21225 return NULL;
21226 }
21227
21228
21229 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21230 PyObject *obj;
21231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21232 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21233 Py_INCREF(obj);
21234 return Py_BuildValue((char *)"");
21235 }
21236 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21239 int arg2 = (int) 0 ;
21240 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21241 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21242 wxContextMenuEvent *result;
21243 wxPoint temp3 ;
21244 PyObject * obj0 = 0 ;
21245 PyObject * obj1 = 0 ;
21246 PyObject * obj2 = 0 ;
21247 char *kwnames[] = {
21248 (char *) "type",(char *) "winid",(char *) "pt", NULL
21249 };
21250
21251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21252 if (obj0) {
21253 {
21254 arg1 = (wxEventType)(SWIG_As_int(obj0));
21255 if (SWIG_arg_fail(1)) SWIG_fail;
21256 }
21257 }
21258 if (obj1) {
21259 {
21260 arg2 = (int)(SWIG_As_int(obj1));
21261 if (SWIG_arg_fail(2)) SWIG_fail;
21262 }
21263 }
21264 if (obj2) {
21265 {
21266 arg3 = &temp3;
21267 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21268 }
21269 }
21270 {
21271 PyThreadState* __tstate = wxPyBeginAllowThreads();
21272 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21273
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21285 PyObject *resultobj;
21286 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21287 wxPoint *result;
21288 PyObject * obj0 = 0 ;
21289 char *kwnames[] = {
21290 (char *) "self", NULL
21291 };
21292
21293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21295 if (SWIG_arg_fail(1)) SWIG_fail;
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 {
21299 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21300 result = (wxPoint *) &_result_ref;
21301 }
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj;
21315 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21316 wxPoint *arg2 = 0 ;
21317 wxPoint temp2 ;
21318 PyObject * obj0 = 0 ;
21319 PyObject * obj1 = 0 ;
21320 char *kwnames[] = {
21321 (char *) "self",(char *) "pos", NULL
21322 };
21323
21324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21326 if (SWIG_arg_fail(1)) SWIG_fail;
21327 {
21328 arg2 = &temp2;
21329 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 (arg1)->SetPosition((wxPoint const &)*arg2);
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 Py_INCREF(Py_None); resultobj = Py_None;
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21346 PyObject *obj;
21347 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21348 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21349 Py_INCREF(obj);
21350 return Py_BuildValue((char *)"");
21351 }
21352 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21353 PyObject *resultobj;
21354 wxIdleEvent *result;
21355 char *kwnames[] = {
21356 NULL
21357 };
21358
21359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21360 {
21361 PyThreadState* __tstate = wxPyBeginAllowThreads();
21362 result = (wxIdleEvent *)new wxIdleEvent();
21363
21364 wxPyEndAllowThreads(__tstate);
21365 if (PyErr_Occurred()) SWIG_fail;
21366 }
21367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21375 PyObject *resultobj;
21376 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21377 bool arg2 = (bool) true ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 char *kwnames[] = {
21381 (char *) "self",(char *) "needMore", NULL
21382 };
21383
21384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 if (obj1) {
21388 {
21389 arg2 = (bool)(SWIG_As_bool(obj1));
21390 if (SWIG_arg_fail(2)) SWIG_fail;
21391 }
21392 }
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 (arg1)->RequestMore(arg2);
21396
21397 wxPyEndAllowThreads(__tstate);
21398 if (PyErr_Occurred()) SWIG_fail;
21399 }
21400 Py_INCREF(Py_None); resultobj = Py_None;
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj;
21409 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21410 bool result;
21411 PyObject * obj0 = 0 ;
21412 char *kwnames[] = {
21413 (char *) "self", NULL
21414 };
21415
21416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21418 if (SWIG_arg_fail(1)) SWIG_fail;
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 {
21427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21428 }
21429 return resultobj;
21430 fail:
21431 return NULL;
21432 }
21433
21434
21435 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21436 PyObject *resultobj;
21437 wxIdleMode arg1 ;
21438 PyObject * obj0 = 0 ;
21439 char *kwnames[] = {
21440 (char *) "mode", NULL
21441 };
21442
21443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21444 {
21445 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21446 if (SWIG_arg_fail(1)) SWIG_fail;
21447 }
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 wxIdleEvent::SetMode((wxIdleMode )arg1);
21451
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 Py_INCREF(Py_None); resultobj = Py_None;
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj;
21464 wxIdleMode result;
21465 char *kwnames[] = {
21466 NULL
21467 };
21468
21469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21470 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (wxIdleMode)wxIdleEvent::GetMode();
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 resultobj = SWIG_From_int((result));
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj;
21486 wxWindow *arg1 = (wxWindow *) 0 ;
21487 bool result;
21488 PyObject * obj0 = 0 ;
21489 char *kwnames[] = {
21490 (char *) "win", NULL
21491 };
21492
21493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21495 if (SWIG_arg_fail(1)) SWIG_fail;
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (bool)wxIdleEvent::CanSend(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21513 PyObject *obj;
21514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21515 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21516 Py_INCREF(obj);
21517 return Py_BuildValue((char *)"");
21518 }
21519 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj;
21521 int arg1 = (int) 0 ;
21522 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21523 wxPyEvent *result;
21524 PyObject * obj0 = 0 ;
21525 PyObject * obj1 = 0 ;
21526 char *kwnames[] = {
21527 (char *) "winid",(char *) "commandType", NULL
21528 };
21529
21530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21531 if (obj0) {
21532 {
21533 arg1 = (int)(SWIG_As_int(obj0));
21534 if (SWIG_arg_fail(1)) SWIG_fail;
21535 }
21536 }
21537 if (obj1) {
21538 {
21539 arg2 = (wxEventType)(SWIG_As_int(obj1));
21540 if (SWIG_arg_fail(2)) SWIG_fail;
21541 }
21542 }
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21546
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj;
21559 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21560 PyObject * obj0 = 0 ;
21561 char *kwnames[] = {
21562 (char *) "self", NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21567 if (SWIG_arg_fail(1)) SWIG_fail;
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 delete arg1;
21571
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 Py_INCREF(Py_None); resultobj = Py_None;
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21585 PyObject *arg2 = (PyObject *) 0 ;
21586 PyObject * obj0 = 0 ;
21587 PyObject * obj1 = 0 ;
21588 char *kwnames[] = {
21589 (char *) "self",(char *) "self", NULL
21590 };
21591
21592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21594 if (SWIG_arg_fail(1)) SWIG_fail;
21595 arg2 = obj1;
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 (arg1)->SetSelf(arg2);
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 Py_INCREF(Py_None); resultobj = Py_None;
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21613 PyObject *result;
21614 PyObject * obj0 = 0 ;
21615 char *kwnames[] = {
21616 (char *) "self", NULL
21617 };
21618
21619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21621 if (SWIG_arg_fail(1)) SWIG_fail;
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (PyObject *)(arg1)->GetSelf();
21625
21626 wxPyEndAllowThreads(__tstate);
21627 if (PyErr_Occurred()) SWIG_fail;
21628 }
21629 resultobj = result;
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21637 PyObject *obj;
21638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21639 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21640 Py_INCREF(obj);
21641 return Py_BuildValue((char *)"");
21642 }
21643 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21644 PyObject *resultobj;
21645 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21646 int arg2 = (int) 0 ;
21647 wxPyCommandEvent *result;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char *kwnames[] = {
21651 (char *) "commandType",(char *) "id", NULL
21652 };
21653
21654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21655 if (obj0) {
21656 {
21657 arg1 = (wxEventType)(SWIG_As_int(obj0));
21658 if (SWIG_arg_fail(1)) SWIG_fail;
21659 }
21660 }
21661 if (obj1) {
21662 {
21663 arg2 = (int)(SWIG_As_int(obj1));
21664 if (SWIG_arg_fail(2)) SWIG_fail;
21665 }
21666 }
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21670
21671 wxPyEndAllowThreads(__tstate);
21672 if (PyErr_Occurred()) SWIG_fail;
21673 }
21674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21675 return resultobj;
21676 fail:
21677 return NULL;
21678 }
21679
21680
21681 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21682 PyObject *resultobj;
21683 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21684 PyObject * obj0 = 0 ;
21685 char *kwnames[] = {
21686 (char *) "self", NULL
21687 };
21688
21689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21691 if (SWIG_arg_fail(1)) SWIG_fail;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 delete arg1;
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21709 PyObject *arg2 = (PyObject *) 0 ;
21710 PyObject * obj0 = 0 ;
21711 PyObject * obj1 = 0 ;
21712 char *kwnames[] = {
21713 (char *) "self",(char *) "self", NULL
21714 };
21715
21716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21718 if (SWIG_arg_fail(1)) SWIG_fail;
21719 arg2 = obj1;
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 (arg1)->SetSelf(arg2);
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 Py_INCREF(Py_None); resultobj = Py_None;
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj;
21736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21737 PyObject *result;
21738 PyObject * obj0 = 0 ;
21739 char *kwnames[] = {
21740 (char *) "self", NULL
21741 };
21742
21743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21745 if (SWIG_arg_fail(1)) SWIG_fail;
21746 {
21747 PyThreadState* __tstate = wxPyBeginAllowThreads();
21748 result = (PyObject *)(arg1)->GetSelf();
21749
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 resultobj = result;
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21761 PyObject *obj;
21762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21763 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21764 Py_INCREF(obj);
21765 return Py_BuildValue((char *)"");
21766 }
21767 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21768 PyObject *resultobj;
21769 wxPyApp *result;
21770 char *kwnames[] = {
21771 NULL
21772 };
21773
21774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (wxPyApp *)new_wxPyApp();
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxPyApp *arg1 = (wxPyApp *) 0 ;
21792 PyObject * obj0 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "self", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21799 if (SWIG_arg_fail(1)) SWIG_fail;
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 delete arg1;
21803
21804 wxPyEndAllowThreads(__tstate);
21805 if (PyErr_Occurred()) SWIG_fail;
21806 }
21807 Py_INCREF(Py_None); resultobj = Py_None;
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21815 PyObject *resultobj;
21816 wxPyApp *arg1 = (wxPyApp *) 0 ;
21817 PyObject *arg2 = (PyObject *) 0 ;
21818 PyObject *arg3 = (PyObject *) 0 ;
21819 PyObject * obj0 = 0 ;
21820 PyObject * obj1 = 0 ;
21821 PyObject * obj2 = 0 ;
21822 char *kwnames[] = {
21823 (char *) "self",(char *) "self",(char *) "_class", NULL
21824 };
21825
21826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21828 if (SWIG_arg_fail(1)) SWIG_fail;
21829 arg2 = obj1;
21830 arg3 = obj2;
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->_setCallbackInfo(arg2,arg3);
21834
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 Py_INCREF(Py_None); resultobj = Py_None;
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21846 PyObject *resultobj;
21847 wxPyApp *arg1 = (wxPyApp *) 0 ;
21848 wxString result;
21849 PyObject * obj0 = 0 ;
21850 char *kwnames[] = {
21851 (char *) "self", NULL
21852 };
21853
21854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(1)) SWIG_fail;
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = ((wxPyApp const *)arg1)->GetAppName();
21860
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 {
21865 #if wxUSE_UNICODE
21866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21867 #else
21868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21869 #endif
21870 }
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxPyApp *arg1 = (wxPyApp *) 0 ;
21880 wxString *arg2 = 0 ;
21881 bool temp2 = false ;
21882 PyObject * obj0 = 0 ;
21883 PyObject * obj1 = 0 ;
21884 char *kwnames[] = {
21885 (char *) "self",(char *) "name", NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21890 if (SWIG_arg_fail(1)) SWIG_fail;
21891 {
21892 arg2 = wxString_in_helper(obj1);
21893 if (arg2 == NULL) SWIG_fail;
21894 temp2 = true;
21895 }
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 (arg1)->SetAppName((wxString const &)*arg2);
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 Py_INCREF(Py_None); resultobj = Py_None;
21904 {
21905 if (temp2)
21906 delete arg2;
21907 }
21908 return resultobj;
21909 fail:
21910 {
21911 if (temp2)
21912 delete arg2;
21913 }
21914 return NULL;
21915 }
21916
21917
21918 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj;
21920 wxPyApp *arg1 = (wxPyApp *) 0 ;
21921 wxString result;
21922 PyObject * obj0 = 0 ;
21923 char *kwnames[] = {
21924 (char *) "self", NULL
21925 };
21926
21927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
21928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21929 if (SWIG_arg_fail(1)) SWIG_fail;
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = ((wxPyApp const *)arg1)->GetClassName();
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 #if wxUSE_UNICODE
21939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21940 #else
21941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21942 #endif
21943 }
21944 return resultobj;
21945 fail:
21946 return NULL;
21947 }
21948
21949
21950 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
21951 PyObject *resultobj;
21952 wxPyApp *arg1 = (wxPyApp *) 0 ;
21953 wxString *arg2 = 0 ;
21954 bool temp2 = false ;
21955 PyObject * obj0 = 0 ;
21956 PyObject * obj1 = 0 ;
21957 char *kwnames[] = {
21958 (char *) "self",(char *) "name", NULL
21959 };
21960
21961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
21962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21963 if (SWIG_arg_fail(1)) SWIG_fail;
21964 {
21965 arg2 = wxString_in_helper(obj1);
21966 if (arg2 == NULL) SWIG_fail;
21967 temp2 = true;
21968 }
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 (arg1)->SetClassName((wxString const &)*arg2);
21972
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 Py_INCREF(Py_None); resultobj = Py_None;
21977 {
21978 if (temp2)
21979 delete arg2;
21980 }
21981 return resultobj;
21982 fail:
21983 {
21984 if (temp2)
21985 delete arg2;
21986 }
21987 return NULL;
21988 }
21989
21990
21991 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj;
21993 wxPyApp *arg1 = (wxPyApp *) 0 ;
21994 wxString *result;
21995 PyObject * obj0 = 0 ;
21996 char *kwnames[] = {
21997 (char *) "self", NULL
21998 };
21999
22000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 {
22006 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22007 result = (wxString *) &_result_ref;
22008 }
22009
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 {
22014 #if wxUSE_UNICODE
22015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22016 #else
22017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22018 #endif
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxPyApp *arg1 = (wxPyApp *) 0 ;
22029 wxString *arg2 = 0 ;
22030 bool temp2 = false ;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 char *kwnames[] = {
22034 (char *) "self",(char *) "name", NULL
22035 };
22036
22037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(1)) SWIG_fail;
22040 {
22041 arg2 = wxString_in_helper(obj1);
22042 if (arg2 == NULL) SWIG_fail;
22043 temp2 = true;
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 (arg1)->SetVendorName((wxString const &)*arg2);
22048
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 Py_INCREF(Py_None); resultobj = Py_None;
22053 {
22054 if (temp2)
22055 delete arg2;
22056 }
22057 return resultobj;
22058 fail:
22059 {
22060 if (temp2)
22061 delete arg2;
22062 }
22063 return NULL;
22064 }
22065
22066
22067 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22068 PyObject *resultobj;
22069 wxPyApp *arg1 = (wxPyApp *) 0 ;
22070 wxAppTraits *result;
22071 PyObject * obj0 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (wxAppTraits *)(arg1)->GetTraits();
22082
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22094 PyObject *resultobj;
22095 wxPyApp *arg1 = (wxPyApp *) 0 ;
22096 PyObject * obj0 = 0 ;
22097 char *kwnames[] = {
22098 (char *) "self", NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(1)) SWIG_fail;
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 (arg1)->ProcessPendingEvents();
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 Py_INCREF(Py_None); resultobj = Py_None;
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj;
22120 wxPyApp *arg1 = (wxPyApp *) 0 ;
22121 bool arg2 = (bool) false ;
22122 bool result;
22123 PyObject * obj0 = 0 ;
22124 PyObject * obj1 = 0 ;
22125 char *kwnames[] = {
22126 (char *) "self",(char *) "onlyIfNeeded", NULL
22127 };
22128
22129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22131 if (SWIG_arg_fail(1)) SWIG_fail;
22132 if (obj1) {
22133 {
22134 arg2 = (bool)(SWIG_As_bool(obj1));
22135 if (SWIG_arg_fail(2)) SWIG_fail;
22136 }
22137 }
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (bool)(arg1)->Yield(arg2);
22141
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 {
22146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22147 }
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22155 PyObject *resultobj;
22156 wxPyApp *arg1 = (wxPyApp *) 0 ;
22157 PyObject * obj0 = 0 ;
22158 char *kwnames[] = {
22159 (char *) "self", NULL
22160 };
22161
22162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22164 if (SWIG_arg_fail(1)) SWIG_fail;
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 (arg1)->WakeUpIdle();
22168
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 Py_INCREF(Py_None); resultobj = Py_None;
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj;
22181 bool result;
22182 char *kwnames[] = {
22183 NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (bool)wxPyApp::IsMainLoopRunning();
22190
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 {
22195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22196 }
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj;
22205 wxPyApp *arg1 = (wxPyApp *) 0 ;
22206 int result;
22207 PyObject * obj0 = 0 ;
22208 char *kwnames[] = {
22209 (char *) "self", NULL
22210 };
22211
22212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22214 if (SWIG_arg_fail(1)) SWIG_fail;
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = (int)(arg1)->MainLoop();
22218
22219 wxPyEndAllowThreads(__tstate);
22220 if (PyErr_Occurred()) SWIG_fail;
22221 }
22222 {
22223 resultobj = SWIG_From_int((int)(result));
22224 }
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxPyApp *arg1 = (wxPyApp *) 0 ;
22234 PyObject * obj0 = 0 ;
22235 char *kwnames[] = {
22236 (char *) "self", NULL
22237 };
22238
22239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(1)) SWIG_fail;
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 (arg1)->Exit();
22245
22246 wxPyEndAllowThreads(__tstate);
22247 if (PyErr_Occurred()) SWIG_fail;
22248 }
22249 Py_INCREF(Py_None); resultobj = Py_None;
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22257 PyObject *resultobj;
22258 wxPyApp *arg1 = (wxPyApp *) 0 ;
22259 PyObject * obj0 = 0 ;
22260 char *kwnames[] = {
22261 (char *) "self", NULL
22262 };
22263
22264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22266 if (SWIG_arg_fail(1)) SWIG_fail;
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 (arg1)->ExitMainLoop();
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 Py_INCREF(Py_None); resultobj = Py_None;
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22282 PyObject *resultobj;
22283 wxPyApp *arg1 = (wxPyApp *) 0 ;
22284 bool result;
22285 PyObject * obj0 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "self", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22292 if (SWIG_arg_fail(1)) SWIG_fail;
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (bool)(arg1)->Pending();
22296
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 {
22301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22302 }
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22310 PyObject *resultobj;
22311 wxPyApp *arg1 = (wxPyApp *) 0 ;
22312 bool result;
22313 PyObject * obj0 = 0 ;
22314 char *kwnames[] = {
22315 (char *) "self", NULL
22316 };
22317
22318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22320 if (SWIG_arg_fail(1)) SWIG_fail;
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 result = (bool)(arg1)->Dispatch();
22324
22325 wxPyEndAllowThreads(__tstate);
22326 if (PyErr_Occurred()) SWIG_fail;
22327 }
22328 {
22329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22330 }
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22338 PyObject *resultobj;
22339 wxPyApp *arg1 = (wxPyApp *) 0 ;
22340 bool result;
22341 PyObject * obj0 = 0 ;
22342 char *kwnames[] = {
22343 (char *) "self", NULL
22344 };
22345
22346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(1)) SWIG_fail;
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 result = (bool)(arg1)->ProcessIdle();
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 {
22357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22358 }
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22366 PyObject *resultobj;
22367 wxPyApp *arg1 = (wxPyApp *) 0 ;
22368 wxWindow *arg2 = (wxWindow *) 0 ;
22369 wxIdleEvent *arg3 = 0 ;
22370 bool result;
22371 PyObject * obj0 = 0 ;
22372 PyObject * obj1 = 0 ;
22373 PyObject * obj2 = 0 ;
22374 char *kwnames[] = {
22375 (char *) "self",(char *) "win",(char *) "event", NULL
22376 };
22377
22378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22380 if (SWIG_arg_fail(1)) SWIG_fail;
22381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 {
22384 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(3)) SWIG_fail;
22386 if (arg3 == NULL) {
22387 SWIG_null_ref("wxIdleEvent");
22388 }
22389 if (SWIG_arg_fail(3)) SWIG_fail;
22390 }
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 {
22399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22400 }
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22408 PyObject *resultobj;
22409 wxPyApp *arg1 = (wxPyApp *) 0 ;
22410 bool result;
22411 PyObject * obj0 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "self", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (bool)((wxPyApp const *)arg1)->IsActive();
22422
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 {
22427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22428 }
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22436 PyObject *resultobj;
22437 wxPyApp *arg1 = (wxPyApp *) 0 ;
22438 wxWindow *arg2 = (wxWindow *) 0 ;
22439 PyObject * obj0 = 0 ;
22440 PyObject * obj1 = 0 ;
22441 char *kwnames[] = {
22442 (char *) "self",(char *) "win", NULL
22443 };
22444
22445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22447 if (SWIG_arg_fail(1)) SWIG_fail;
22448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22449 if (SWIG_arg_fail(2)) SWIG_fail;
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 (arg1)->SetTopWindow(arg2);
22453
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 Py_INCREF(Py_None); resultobj = Py_None;
22458 return resultobj;
22459 fail:
22460 return NULL;
22461 }
22462
22463
22464 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22465 PyObject *resultobj;
22466 wxPyApp *arg1 = (wxPyApp *) 0 ;
22467 wxWindow *result;
22468 PyObject * obj0 = 0 ;
22469 char *kwnames[] = {
22470 (char *) "self", NULL
22471 };
22472
22473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22475 if (SWIG_arg_fail(1)) SWIG_fail;
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 {
22484 resultobj = wxPyMake_wxObject(result, 0);
22485 }
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj;
22494 wxPyApp *arg1 = (wxPyApp *) 0 ;
22495 bool arg2 ;
22496 PyObject * obj0 = 0 ;
22497 PyObject * obj1 = 0 ;
22498 char *kwnames[] = {
22499 (char *) "self",(char *) "flag", NULL
22500 };
22501
22502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22504 if (SWIG_arg_fail(1)) SWIG_fail;
22505 {
22506 arg2 = (bool)(SWIG_As_bool(obj1));
22507 if (SWIG_arg_fail(2)) SWIG_fail;
22508 }
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 (arg1)->SetExitOnFrameDelete(arg2);
22512
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 Py_INCREF(Py_None); resultobj = Py_None;
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj;
22525 wxPyApp *arg1 = (wxPyApp *) 0 ;
22526 bool result;
22527 PyObject * obj0 = 0 ;
22528 char *kwnames[] = {
22529 (char *) "self", NULL
22530 };
22531
22532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(1)) SWIG_fail;
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22538
22539 wxPyEndAllowThreads(__tstate);
22540 if (PyErr_Occurred()) SWIG_fail;
22541 }
22542 {
22543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22544 }
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22552 PyObject *resultobj;
22553 wxPyApp *arg1 = (wxPyApp *) 0 ;
22554 bool arg2 ;
22555 PyObject * obj0 = 0 ;
22556 PyObject * obj1 = 0 ;
22557 char *kwnames[] = {
22558 (char *) "self",(char *) "flag", NULL
22559 };
22560
22561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(1)) SWIG_fail;
22564 {
22565 arg2 = (bool)(SWIG_As_bool(obj1));
22566 if (SWIG_arg_fail(2)) SWIG_fail;
22567 }
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 (arg1)->SetUseBestVisual(arg2);
22571
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 Py_INCREF(Py_None); resultobj = Py_None;
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22583 PyObject *resultobj;
22584 wxPyApp *arg1 = (wxPyApp *) 0 ;
22585 bool result;
22586 PyObject * obj0 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22597
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 {
22602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22603 }
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj;
22612 wxPyApp *arg1 = (wxPyApp *) 0 ;
22613 int arg2 ;
22614 PyObject * obj0 = 0 ;
22615 PyObject * obj1 = 0 ;
22616 char *kwnames[] = {
22617 (char *) "self",(char *) "mode", NULL
22618 };
22619
22620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22622 if (SWIG_arg_fail(1)) SWIG_fail;
22623 {
22624 arg2 = (int)(SWIG_As_int(obj1));
22625 if (SWIG_arg_fail(2)) SWIG_fail;
22626 }
22627 {
22628 PyThreadState* __tstate = wxPyBeginAllowThreads();
22629 (arg1)->SetPrintMode(arg2);
22630
22631 wxPyEndAllowThreads(__tstate);
22632 if (PyErr_Occurred()) SWIG_fail;
22633 }
22634 Py_INCREF(Py_None); resultobj = Py_None;
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22642 PyObject *resultobj;
22643 wxPyApp *arg1 = (wxPyApp *) 0 ;
22644 int result;
22645 PyObject * obj0 = 0 ;
22646 char *kwnames[] = {
22647 (char *) "self", NULL
22648 };
22649
22650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(1)) SWIG_fail;
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 {
22661 resultobj = SWIG_From_int((int)(result));
22662 }
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj;
22671 wxPyApp *arg1 = (wxPyApp *) 0 ;
22672 int arg2 ;
22673 PyObject * obj0 = 0 ;
22674 PyObject * obj1 = 0 ;
22675 char *kwnames[] = {
22676 (char *) "self",(char *) "mode", NULL
22677 };
22678
22679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 {
22683 arg2 = (int)(SWIG_As_int(obj1));
22684 if (SWIG_arg_fail(2)) SWIG_fail;
22685 }
22686 {
22687 PyThreadState* __tstate = wxPyBeginAllowThreads();
22688 (arg1)->SetAssertMode(arg2);
22689
22690 wxPyEndAllowThreads(__tstate);
22691 if (PyErr_Occurred()) SWIG_fail;
22692 }
22693 Py_INCREF(Py_None); resultobj = Py_None;
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22701 PyObject *resultobj;
22702 wxPyApp *arg1 = (wxPyApp *) 0 ;
22703 int result;
22704 PyObject * obj0 = 0 ;
22705 char *kwnames[] = {
22706 (char *) "self", NULL
22707 };
22708
22709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22711 if (SWIG_arg_fail(1)) SWIG_fail;
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 result = (int)(arg1)->GetAssertMode();
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 {
22720 resultobj = SWIG_From_int((int)(result));
22721 }
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj;
22730 bool result;
22731 char *kwnames[] = {
22732 NULL
22733 };
22734
22735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22745 }
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj;
22754 long result;
22755 char *kwnames[] = {
22756 NULL
22757 };
22758
22759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22760 {
22761 PyThreadState* __tstate = wxPyBeginAllowThreads();
22762 result = (long)wxPyApp::GetMacAboutMenuItemId();
22763
22764 wxPyEndAllowThreads(__tstate);
22765 if (PyErr_Occurred()) SWIG_fail;
22766 }
22767 {
22768 resultobj = SWIG_From_long((long)(result));
22769 }
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22777 PyObject *resultobj;
22778 long result;
22779 char *kwnames[] = {
22780 NULL
22781 };
22782
22783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22787
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 {
22792 resultobj = SWIG_From_long((long)(result));
22793 }
22794 return resultobj;
22795 fail:
22796 return NULL;
22797 }
22798
22799
22800 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22801 PyObject *resultobj;
22802 long result;
22803 char *kwnames[] = {
22804 NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (long)wxPyApp::GetMacExitMenuItemId();
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = SWIG_From_long((long)(result));
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 wxString result;
22827 char *kwnames[] = {
22828 NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 result = wxPyApp::GetMacHelpMenuTitleName();
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 #if wxUSE_UNICODE
22841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22842 #else
22843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22844 #endif
22845 }
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22853 PyObject *resultobj;
22854 bool arg1 ;
22855 PyObject * obj0 = 0 ;
22856 char *kwnames[] = {
22857 (char *) "val", NULL
22858 };
22859
22860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22861 {
22862 arg1 = (bool)(SWIG_As_bool(obj0));
22863 if (SWIG_arg_fail(1)) SWIG_fail;
22864 }
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22868
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 Py_INCREF(Py_None); resultobj = Py_None;
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22880 PyObject *resultobj;
22881 long arg1 ;
22882 PyObject * obj0 = 0 ;
22883 char *kwnames[] = {
22884 (char *) "val", NULL
22885 };
22886
22887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22888 {
22889 arg1 = (long)(SWIG_As_long(obj0));
22890 if (SWIG_arg_fail(1)) SWIG_fail;
22891 }
22892 {
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 wxPyApp::SetMacAboutMenuItemId(arg1);
22895
22896 wxPyEndAllowThreads(__tstate);
22897 if (PyErr_Occurred()) SWIG_fail;
22898 }
22899 Py_INCREF(Py_None); resultobj = Py_None;
22900 return resultobj;
22901 fail:
22902 return NULL;
22903 }
22904
22905
22906 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22907 PyObject *resultobj;
22908 long arg1 ;
22909 PyObject * obj0 = 0 ;
22910 char *kwnames[] = {
22911 (char *) "val", NULL
22912 };
22913
22914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
22915 {
22916 arg1 = (long)(SWIG_As_long(obj0));
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 wxPyApp::SetMacPreferencesMenuItemId(arg1);
22922
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 Py_INCREF(Py_None); resultobj = Py_None;
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22934 PyObject *resultobj;
22935 long arg1 ;
22936 PyObject * obj0 = 0 ;
22937 char *kwnames[] = {
22938 (char *) "val", NULL
22939 };
22940
22941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
22942 {
22943 arg1 = (long)(SWIG_As_long(obj0));
22944 if (SWIG_arg_fail(1)) SWIG_fail;
22945 }
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 wxPyApp::SetMacExitMenuItemId(arg1);
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 Py_INCREF(Py_None); resultobj = Py_None;
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj;
22962 wxString *arg1 = 0 ;
22963 bool temp1 = false ;
22964 PyObject * obj0 = 0 ;
22965 char *kwnames[] = {
22966 (char *) "val", NULL
22967 };
22968
22969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
22970 {
22971 arg1 = wxString_in_helper(obj0);
22972 if (arg1 == NULL) SWIG_fail;
22973 temp1 = true;
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
22978
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 Py_INCREF(Py_None); resultobj = Py_None;
22983 {
22984 if (temp1)
22985 delete arg1;
22986 }
22987 return resultobj;
22988 fail:
22989 {
22990 if (temp1)
22991 delete arg1;
22992 }
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxPyApp *arg1 = (wxPyApp *) 0 ;
23000 PyObject * obj0 = 0 ;
23001 char *kwnames[] = {
23002 (char *) "self", NULL
23003 };
23004
23005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23007 if (SWIG_arg_fail(1)) SWIG_fail;
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 (arg1)->_BootstrapApp();
23011
23012 wxPyEndAllowThreads(__tstate);
23013 if (PyErr_Occurred()) SWIG_fail;
23014 }
23015 Py_INCREF(Py_None); resultobj = Py_None;
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23023 PyObject *resultobj;
23024 int result;
23025 char *kwnames[] = {
23026 NULL
23027 };
23028
23029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 result = (int)PyApp_GetComCtl32Version();
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 {
23038 resultobj = SWIG_From_int((int)(result));
23039 }
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23047 PyObject *obj;
23048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23049 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23050 Py_INCREF(obj);
23051 return Py_BuildValue((char *)"");
23052 }
23053 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23054 PyObject *resultobj;
23055 char *kwnames[] = {
23056 NULL
23057 };
23058
23059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 wxExit();
23063
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 Py_INCREF(Py_None); resultobj = Py_None;
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj;
23076 bool result;
23077 char *kwnames[] = {
23078 NULL
23079 };
23080
23081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)wxYield();
23085
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 {
23090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj;
23100 bool result;
23101 char *kwnames[] = {
23102 NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 result = (bool)wxYieldIfNeeded();
23109
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 {
23114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23115 }
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxWindow *arg1 = (wxWindow *) NULL ;
23125 bool arg2 = (bool) false ;
23126 bool result;
23127 PyObject * obj0 = 0 ;
23128 PyObject * obj1 = 0 ;
23129 char *kwnames[] = {
23130 (char *) "win",(char *) "onlyIfNeeded", NULL
23131 };
23132
23133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23134 if (obj0) {
23135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23136 if (SWIG_arg_fail(1)) SWIG_fail;
23137 }
23138 if (obj1) {
23139 {
23140 arg2 = (bool)(SWIG_As_bool(obj1));
23141 if (SWIG_arg_fail(2)) SWIG_fail;
23142 }
23143 }
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (bool)wxSafeYield(arg1,arg2);
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_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 char *kwnames[] = {
23163 NULL
23164 };
23165
23166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 wxWakeUpIdle();
23170
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 Py_INCREF(Py_None); resultobj = Py_None;
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj;
23183 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23184 wxEvent *arg2 = 0 ;
23185 PyObject * obj0 = 0 ;
23186 PyObject * obj1 = 0 ;
23187 char *kwnames[] = {
23188 (char *) "dest",(char *) "event", NULL
23189 };
23190
23191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23193 if (SWIG_arg_fail(1)) SWIG_fail;
23194 {
23195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23196 if (SWIG_arg_fail(2)) SWIG_fail;
23197 if (arg2 == NULL) {
23198 SWIG_null_ref("wxEvent");
23199 }
23200 if (SWIG_arg_fail(2)) SWIG_fail;
23201 }
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 wxPostEvent(arg1,*arg2);
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 Py_INCREF(Py_None); resultobj = Py_None;
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 char *kwnames[] = {
23219 NULL
23220 };
23221
23222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 wxApp_CleanUp();
23226
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 Py_INCREF(Py_None); resultobj = Py_None;
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj;
23239 wxPyApp *result;
23240 char *kwnames[] = {
23241 NULL
23242 };
23243
23244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 result = (wxPyApp *)wxPyGetApp();
23248
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 {
23253 resultobj = wxPyMake_wxObject(result, 0);
23254 }
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj;
23263 char *arg1 = (char *) 0 ;
23264 PyObject * obj0 = 0 ;
23265 char *kwnames[] = {
23266 (char *) "encoding", NULL
23267 };
23268
23269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23270 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23271 SWIG_arg_fail(1);SWIG_fail;
23272 }
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 wxSetDefaultPyEncoding((char const *)arg1);
23276
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 Py_INCREF(Py_None); resultobj = Py_None;
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23288 PyObject *resultobj;
23289 char *result;
23290 char *kwnames[] = {
23291 NULL
23292 };
23293
23294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (char *)wxGetDefaultPyEncoding();
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 resultobj = SWIG_FromCharPtr(result);
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj;
23311 wxEventLoop *result;
23312 char *kwnames[] = {
23313 NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (wxEventLoop *)new wxEventLoop();
23320
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23334 PyObject * obj0 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 delete arg1;
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 Py_INCREF(Py_None); resultobj = Py_None;
23350 return resultobj;
23351 fail:
23352 return NULL;
23353 }
23354
23355
23356 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23357 PyObject *resultobj;
23358 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23359 int result;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "self", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(1)) SWIG_fail;
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = (int)(arg1)->Run();
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 {
23376 resultobj = SWIG_From_int((int)(result));
23377 }
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj;
23386 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23387 int arg2 = (int) 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self",(char *) "rc", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 if (obj1) {
23398 {
23399 arg2 = (int)(SWIG_As_int(obj1));
23400 if (SWIG_arg_fail(2)) SWIG_fail;
23401 }
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 (arg1)->Exit(arg2);
23406
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 Py_INCREF(Py_None); resultobj = Py_None;
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23420 bool result;
23421 PyObject * obj0 = 0 ;
23422 char *kwnames[] = {
23423 (char *) "self", NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23428 if (SWIG_arg_fail(1)) SWIG_fail;
23429 {
23430 PyThreadState* __tstate = wxPyBeginAllowThreads();
23431 result = (bool)((wxEventLoop const *)arg1)->Pending();
23432
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 {
23437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23438 }
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj;
23447 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23448 bool result;
23449 PyObject * obj0 = 0 ;
23450 char *kwnames[] = {
23451 (char *) "self", NULL
23452 };
23453
23454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23456 if (SWIG_arg_fail(1)) SWIG_fail;
23457 {
23458 PyThreadState* __tstate = wxPyBeginAllowThreads();
23459 result = (bool)(arg1)->Dispatch();
23460
23461 wxPyEndAllowThreads(__tstate);
23462 if (PyErr_Occurred()) SWIG_fail;
23463 }
23464 {
23465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23466 }
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj;
23475 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23476 bool result;
23477 PyObject * obj0 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 PyThreadState* __tstate = wxPyBeginAllowThreads();
23487 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23488
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj;
23503 wxEventLoop *result;
23504 char *kwnames[] = {
23505 NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = (wxEventLoop *)wxEventLoop::GetActive();
23512
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23526 PyObject * obj0 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "loop", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 wxEventLoop::SetActive(arg1);
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 Py_INCREF(Py_None); resultobj = Py_None;
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23549 PyObject *obj;
23550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23551 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23552 Py_INCREF(obj);
23553 return Py_BuildValue((char *)"");
23554 }
23555 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj;
23557 int arg1 = (int) 0 ;
23558 int arg2 = (int) 0 ;
23559 int arg3 = (int) 0 ;
23560 wxAcceleratorEntry *result;
23561 PyObject * obj0 = 0 ;
23562 PyObject * obj1 = 0 ;
23563 PyObject * obj2 = 0 ;
23564 char *kwnames[] = {
23565 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23566 };
23567
23568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23569 if (obj0) {
23570 {
23571 arg1 = (int)(SWIG_As_int(obj0));
23572 if (SWIG_arg_fail(1)) SWIG_fail;
23573 }
23574 }
23575 if (obj1) {
23576 {
23577 arg2 = (int)(SWIG_As_int(obj1));
23578 if (SWIG_arg_fail(2)) SWIG_fail;
23579 }
23580 }
23581 if (obj2) {
23582 {
23583 arg3 = (int)(SWIG_As_int(obj2));
23584 if (SWIG_arg_fail(3)) SWIG_fail;
23585 }
23586 }
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23602 PyObject *resultobj;
23603 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23604 PyObject * obj0 = 0 ;
23605 char *kwnames[] = {
23606 (char *) "self", NULL
23607 };
23608
23609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23611 if (SWIG_arg_fail(1)) SWIG_fail;
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 delete arg1;
23615
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 Py_INCREF(Py_None); resultobj = Py_None;
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj;
23628 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23629 int arg2 ;
23630 int arg3 ;
23631 int arg4 ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 PyObject * obj2 = 0 ;
23635 PyObject * obj3 = 0 ;
23636 char *kwnames[] = {
23637 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23638 };
23639
23640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23642 if (SWIG_arg_fail(1)) SWIG_fail;
23643 {
23644 arg2 = (int)(SWIG_As_int(obj1));
23645 if (SWIG_arg_fail(2)) SWIG_fail;
23646 }
23647 {
23648 arg3 = (int)(SWIG_As_int(obj2));
23649 if (SWIG_arg_fail(3)) SWIG_fail;
23650 }
23651 {
23652 arg4 = (int)(SWIG_As_int(obj3));
23653 if (SWIG_arg_fail(4)) SWIG_fail;
23654 }
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 (arg1)->Set(arg2,arg3,arg4);
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 Py_INCREF(Py_None); resultobj = Py_None;
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj;
23671 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23672 int result;
23673 PyObject * obj0 = 0 ;
23674 char *kwnames[] = {
23675 (char *) "self", NULL
23676 };
23677
23678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23680 if (SWIG_arg_fail(1)) SWIG_fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (int)(arg1)->GetFlags();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 {
23689 resultobj = SWIG_From_int((int)(result));
23690 }
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23700 int result;
23701 PyObject * obj0 = 0 ;
23702 char *kwnames[] = {
23703 (char *) "self", NULL
23704 };
23705
23706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23708 if (SWIG_arg_fail(1)) SWIG_fail;
23709 {
23710 PyThreadState* __tstate = wxPyBeginAllowThreads();
23711 result = (int)(arg1)->GetKeyCode();
23712
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 {
23717 resultobj = SWIG_From_int((int)(result));
23718 }
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj;
23727 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23728 int result;
23729 PyObject * obj0 = 0 ;
23730 char *kwnames[] = {
23731 (char *) "self", NULL
23732 };
23733
23734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23736 if (SWIG_arg_fail(1)) SWIG_fail;
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 result = (int)(arg1)->GetCommand();
23740
23741 wxPyEndAllowThreads(__tstate);
23742 if (PyErr_Occurred()) SWIG_fail;
23743 }
23744 {
23745 resultobj = SWIG_From_int((int)(result));
23746 }
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23754 PyObject *obj;
23755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23756 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23757 Py_INCREF(obj);
23758 return Py_BuildValue((char *)"");
23759 }
23760 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 int arg1 ;
23763 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23764 wxAcceleratorTable *result;
23765 PyObject * obj0 = 0 ;
23766 char *kwnames[] = {
23767 (char *) "n", NULL
23768 };
23769
23770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23771 {
23772 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23773 if (arg2) arg1 = PyList_Size(obj0);
23774 else arg1 = 0;
23775 }
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23779
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23784 {
23785 delete [] arg2;
23786 }
23787 return resultobj;
23788 fail:
23789 {
23790 delete [] arg2;
23791 }
23792 return NULL;
23793 }
23794
23795
23796 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23797 PyObject *resultobj;
23798 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23799 PyObject * obj0 = 0 ;
23800 char *kwnames[] = {
23801 (char *) "self", NULL
23802 };
23803
23804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 delete arg1;
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 Py_INCREF(Py_None); resultobj = Py_None;
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23824 bool result;
23825 PyObject * obj0 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 {
23841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23850 PyObject *obj;
23851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23852 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23853 Py_INCREF(obj);
23854 return Py_BuildValue((char *)"");
23855 }
23856 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23857 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23858 return 1;
23859 }
23860
23861
23862 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23863 PyObject *pyobj;
23864
23865 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23866 return pyobj;
23867 }
23868
23869
23870 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23871 PyObject *resultobj;
23872 wxString *arg1 = 0 ;
23873 wxAcceleratorEntry *result;
23874 bool temp1 = false ;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "label", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23881 {
23882 arg1 = wxString_in_helper(obj0);
23883 if (arg1 == NULL) SWIG_fail;
23884 temp1 = true;
23885 }
23886 {
23887 PyThreadState* __tstate = wxPyBeginAllowThreads();
23888 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23889
23890 wxPyEndAllowThreads(__tstate);
23891 if (PyErr_Occurred()) SWIG_fail;
23892 }
23893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23894 {
23895 if (temp1)
23896 delete arg1;
23897 }
23898 return resultobj;
23899 fail:
23900 {
23901 if (temp1)
23902 delete arg1;
23903 }
23904 return NULL;
23905 }
23906
23907
23908 static int _wrap_PanelNameStr_set(PyObject *) {
23909 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
23910 return 1;
23911 }
23912
23913
23914 static PyObject *_wrap_PanelNameStr_get(void) {
23915 PyObject *pyobj;
23916
23917 {
23918 #if wxUSE_UNICODE
23919 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
23920 #else
23921 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
23922 #endif
23923 }
23924 return pyobj;
23925 }
23926
23927
23928 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
23929 PyObject *resultobj;
23930 wxVisualAttributes *result;
23931 char *kwnames[] = {
23932 NULL
23933 };
23934
23935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (wxVisualAttributes *)new_wxVisualAttributes();
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj;
23952 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
23953 PyObject * obj0 = 0 ;
23954 char *kwnames[] = {
23955 (char *) "self", NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
23959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
23960 if (SWIG_arg_fail(1)) SWIG_fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 delete_wxVisualAttributes(arg1);
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 Py_INCREF(Py_None); resultobj = Py_None;
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj;
23977 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
23978 wxFont *arg2 = (wxFont *) 0 ;
23979 PyObject * obj0 = 0 ;
23980 PyObject * obj1 = 0 ;
23981 char *kwnames[] = {
23982 (char *) "self",(char *) "font", NULL
23983 };
23984
23985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
23986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
23987 if (SWIG_arg_fail(1)) SWIG_fail;
23988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
23989 if (SWIG_arg_fail(2)) SWIG_fail;
23990 if (arg1) (arg1)->font = *arg2;
23991
23992 Py_INCREF(Py_None); resultobj = Py_None;
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24002 wxFont *result;
24003 PyObject * obj0 = 0 ;
24004 char *kwnames[] = {
24005 (char *) "self", NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24010 if (SWIG_arg_fail(1)) SWIG_fail;
24011 result = (wxFont *)& ((arg1)->font);
24012
24013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24021 PyObject *resultobj;
24022 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24023 wxColour *arg2 = (wxColour *) 0 ;
24024 PyObject * obj0 = 0 ;
24025 PyObject * obj1 = 0 ;
24026 char *kwnames[] = {
24027 (char *) "self",(char *) "colFg", NULL
24028 };
24029
24030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24032 if (SWIG_arg_fail(1)) SWIG_fail;
24033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24034 if (SWIG_arg_fail(2)) SWIG_fail;
24035 if (arg1) (arg1)->colFg = *arg2;
24036
24037 Py_INCREF(Py_None); resultobj = Py_None;
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj;
24046 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24047 wxColour *result;
24048 PyObject * obj0 = 0 ;
24049 char *kwnames[] = {
24050 (char *) "self", NULL
24051 };
24052
24053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24055 if (SWIG_arg_fail(1)) SWIG_fail;
24056 result = (wxColour *)& ((arg1)->colFg);
24057
24058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj;
24067 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24068 wxColour *arg2 = (wxColour *) 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char *kwnames[] = {
24072 (char *) "self",(char *) "colBg", NULL
24073 };
24074
24075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24077 if (SWIG_arg_fail(1)) SWIG_fail;
24078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 if (arg1) (arg1)->colBg = *arg2;
24081
24082 Py_INCREF(Py_None); resultobj = Py_None;
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24092 wxColour *result;
24093 PyObject * obj0 = 0 ;
24094 char *kwnames[] = {
24095 (char *) "self", NULL
24096 };
24097
24098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24100 if (SWIG_arg_fail(1)) SWIG_fail;
24101 result = (wxColour *)& ((arg1)->colBg);
24102
24103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24104 return resultobj;
24105 fail:
24106 return NULL;
24107 }
24108
24109
24110 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24111 PyObject *obj;
24112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24113 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24114 Py_INCREF(obj);
24115 return Py_BuildValue((char *)"");
24116 }
24117 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj;
24119 wxWindow *arg1 = (wxWindow *) 0 ;
24120 int arg2 = (int) (int)-1 ;
24121 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24122 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24123 wxSize const &arg4_defvalue = wxDefaultSize ;
24124 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24125 long arg5 = (long) 0 ;
24126 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24127 wxString *arg6 = (wxString *) &arg6_defvalue ;
24128 wxWindow *result;
24129 wxPoint temp3 ;
24130 wxSize temp4 ;
24131 bool temp6 = false ;
24132 PyObject * obj0 = 0 ;
24133 PyObject * obj1 = 0 ;
24134 PyObject * obj2 = 0 ;
24135 PyObject * obj3 = 0 ;
24136 PyObject * obj4 = 0 ;
24137 PyObject * obj5 = 0 ;
24138 char *kwnames[] = {
24139 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24140 };
24141
24142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24144 if (SWIG_arg_fail(1)) SWIG_fail;
24145 if (obj1) {
24146 {
24147 arg2 = (int const)(SWIG_As_int(obj1));
24148 if (SWIG_arg_fail(2)) SWIG_fail;
24149 }
24150 }
24151 if (obj2) {
24152 {
24153 arg3 = &temp3;
24154 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24155 }
24156 }
24157 if (obj3) {
24158 {
24159 arg4 = &temp4;
24160 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24161 }
24162 }
24163 if (obj4) {
24164 {
24165 arg5 = (long)(SWIG_As_long(obj4));
24166 if (SWIG_arg_fail(5)) SWIG_fail;
24167 }
24168 }
24169 if (obj5) {
24170 {
24171 arg6 = wxString_in_helper(obj5);
24172 if (arg6 == NULL) SWIG_fail;
24173 temp6 = true;
24174 }
24175 }
24176 {
24177 if (!wxPyCheckForApp()) SWIG_fail;
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24180
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24185 {
24186 if (temp6)
24187 delete arg6;
24188 }
24189 return resultobj;
24190 fail:
24191 {
24192 if (temp6)
24193 delete arg6;
24194 }
24195 return NULL;
24196 }
24197
24198
24199 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24200 PyObject *resultobj;
24201 wxWindow *result;
24202 char *kwnames[] = {
24203 NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24207 {
24208 if (!wxPyCheckForApp()) SWIG_fail;
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 result = (wxWindow *)new wxWindow();
24211
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj;
24224 wxWindow *arg1 = (wxWindow *) 0 ;
24225 wxWindow *arg2 = (wxWindow *) 0 ;
24226 int arg3 = (int) (int)-1 ;
24227 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24228 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24229 wxSize const &arg5_defvalue = wxDefaultSize ;
24230 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24231 long arg6 = (long) 0 ;
24232 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24233 wxString *arg7 = (wxString *) &arg7_defvalue ;
24234 bool result;
24235 wxPoint temp4 ;
24236 wxSize temp5 ;
24237 bool temp7 = false ;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 PyObject * obj2 = 0 ;
24241 PyObject * obj3 = 0 ;
24242 PyObject * obj4 = 0 ;
24243 PyObject * obj5 = 0 ;
24244 PyObject * obj6 = 0 ;
24245 char *kwnames[] = {
24246 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24247 };
24248
24249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24251 if (SWIG_arg_fail(1)) SWIG_fail;
24252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24253 if (SWIG_arg_fail(2)) SWIG_fail;
24254 if (obj2) {
24255 {
24256 arg3 = (int const)(SWIG_As_int(obj2));
24257 if (SWIG_arg_fail(3)) SWIG_fail;
24258 }
24259 }
24260 if (obj3) {
24261 {
24262 arg4 = &temp4;
24263 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24264 }
24265 }
24266 if (obj4) {
24267 {
24268 arg5 = &temp5;
24269 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24270 }
24271 }
24272 if (obj5) {
24273 {
24274 arg6 = (long)(SWIG_As_long(obj5));
24275 if (SWIG_arg_fail(6)) SWIG_fail;
24276 }
24277 }
24278 if (obj6) {
24279 {
24280 arg7 = wxString_in_helper(obj6);
24281 if (arg7 == NULL) SWIG_fail;
24282 temp7 = true;
24283 }
24284 }
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24294 }
24295 {
24296 if (temp7)
24297 delete arg7;
24298 }
24299 return resultobj;
24300 fail:
24301 {
24302 if (temp7)
24303 delete arg7;
24304 }
24305 return NULL;
24306 }
24307
24308
24309 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24310 PyObject *resultobj;
24311 wxWindow *arg1 = (wxWindow *) 0 ;
24312 bool arg2 = (bool) false ;
24313 bool result;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self",(char *) "force", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 if (obj1) {
24324 {
24325 arg2 = (bool)(SWIG_As_bool(obj1));
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 }
24328 }
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (bool)(arg1)->Close(arg2);
24332
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 {
24337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24338 }
24339 return resultobj;
24340 fail:
24341 return NULL;
24342 }
24343
24344
24345 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24346 PyObject *resultobj;
24347 wxWindow *arg1 = (wxWindow *) 0 ;
24348 bool result;
24349 PyObject * obj0 = 0 ;
24350 char *kwnames[] = {
24351 (char *) "self", NULL
24352 };
24353
24354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24356 if (SWIG_arg_fail(1)) SWIG_fail;
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 result = (bool)(arg1)->Destroy();
24360
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 {
24365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24366 }
24367 return resultobj;
24368 fail:
24369 return NULL;
24370 }
24371
24372
24373 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24374 PyObject *resultobj;
24375 wxWindow *arg1 = (wxWindow *) 0 ;
24376 bool result;
24377 PyObject * obj0 = 0 ;
24378 char *kwnames[] = {
24379 (char *) "self", NULL
24380 };
24381
24382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 result = (bool)(arg1)->DestroyChildren();
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj;
24403 wxWindow *arg1 = (wxWindow *) 0 ;
24404 bool result;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24430 PyObject *resultobj;
24431 wxWindow *arg1 = (wxWindow *) 0 ;
24432 wxString *arg2 = 0 ;
24433 bool temp2 = false ;
24434 PyObject * obj0 = 0 ;
24435 PyObject * obj1 = 0 ;
24436 char *kwnames[] = {
24437 (char *) "self",(char *) "title", NULL
24438 };
24439
24440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24442 if (SWIG_arg_fail(1)) SWIG_fail;
24443 {
24444 arg2 = wxString_in_helper(obj1);
24445 if (arg2 == NULL) SWIG_fail;
24446 temp2 = true;
24447 }
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetTitle((wxString const &)*arg2);
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 Py_INCREF(Py_None); resultobj = Py_None;
24456 {
24457 if (temp2)
24458 delete arg2;
24459 }
24460 return resultobj;
24461 fail:
24462 {
24463 if (temp2)
24464 delete arg2;
24465 }
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxWindow *arg1 = (wxWindow *) 0 ;
24473 wxString result;
24474 PyObject * obj0 = 0 ;
24475 char *kwnames[] = {
24476 (char *) "self", NULL
24477 };
24478
24479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(1)) SWIG_fail;
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 result = ((wxWindow const *)arg1)->GetTitle();
24485
24486 wxPyEndAllowThreads(__tstate);
24487 if (PyErr_Occurred()) SWIG_fail;
24488 }
24489 {
24490 #if wxUSE_UNICODE
24491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24492 #else
24493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24494 #endif
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj;
24504 wxWindow *arg1 = (wxWindow *) 0 ;
24505 wxString *arg2 = 0 ;
24506 bool temp2 = false ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self",(char *) "label", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 arg2 = wxString_in_helper(obj1);
24518 if (arg2 == NULL) SWIG_fail;
24519 temp2 = true;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 (arg1)->SetLabel((wxString const &)*arg2);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 Py_INCREF(Py_None); resultobj = Py_None;
24529 {
24530 if (temp2)
24531 delete arg2;
24532 }
24533 return resultobj;
24534 fail:
24535 {
24536 if (temp2)
24537 delete arg2;
24538 }
24539 return NULL;
24540 }
24541
24542
24543 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24544 PyObject *resultobj;
24545 wxWindow *arg1 = (wxWindow *) 0 ;
24546 wxString result;
24547 PyObject * obj0 = 0 ;
24548 char *kwnames[] = {
24549 (char *) "self", NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(1)) SWIG_fail;
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 result = ((wxWindow const *)arg1)->GetLabel();
24558
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 #if wxUSE_UNICODE
24564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24565 #else
24566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24567 #endif
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj;
24577 wxWindow *arg1 = (wxWindow *) 0 ;
24578 wxString *arg2 = 0 ;
24579 bool temp2 = false ;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "name", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 {
24590 arg2 = wxString_in_helper(obj1);
24591 if (arg2 == NULL) SWIG_fail;
24592 temp2 = true;
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 (arg1)->SetName((wxString const &)*arg2);
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 Py_INCREF(Py_None); resultobj = Py_None;
24602 {
24603 if (temp2)
24604 delete arg2;
24605 }
24606 return resultobj;
24607 fail:
24608 {
24609 if (temp2)
24610 delete arg2;
24611 }
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxWindow *arg1 = (wxWindow *) 0 ;
24619 wxString result;
24620 PyObject * obj0 = 0 ;
24621 char *kwnames[] = {
24622 (char *) "self", NULL
24623 };
24624
24625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24627 if (SWIG_arg_fail(1)) SWIG_fail;
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 result = ((wxWindow const *)arg1)->GetName();
24631
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 {
24636 #if wxUSE_UNICODE
24637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24638 #else
24639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24640 #endif
24641 }
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj;
24650 wxWindow *arg1 = (wxWindow *) 0 ;
24651 wxWindowVariant arg2 ;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 char *kwnames[] = {
24655 (char *) "self",(char *) "variant", NULL
24656 };
24657
24658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24660 if (SWIG_arg_fail(1)) SWIG_fail;
24661 {
24662 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24663 if (SWIG_arg_fail(2)) SWIG_fail;
24664 }
24665 {
24666 PyThreadState* __tstate = wxPyBeginAllowThreads();
24667 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24668
24669 wxPyEndAllowThreads(__tstate);
24670 if (PyErr_Occurred()) SWIG_fail;
24671 }
24672 Py_INCREF(Py_None); resultobj = Py_None;
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj;
24681 wxWindow *arg1 = (wxWindow *) 0 ;
24682 wxWindowVariant result;
24683 PyObject * obj0 = 0 ;
24684 char *kwnames[] = {
24685 (char *) "self", NULL
24686 };
24687
24688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24690 if (SWIG_arg_fail(1)) SWIG_fail;
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24694
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_From_int((result));
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24706 PyObject *resultobj;
24707 wxWindow *arg1 = (wxWindow *) 0 ;
24708 int arg2 ;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 char *kwnames[] = {
24712 (char *) "self",(char *) "winid", NULL
24713 };
24714
24715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24717 if (SWIG_arg_fail(1)) SWIG_fail;
24718 {
24719 arg2 = (int)(SWIG_As_int(obj1));
24720 if (SWIG_arg_fail(2)) SWIG_fail;
24721 }
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 (arg1)->SetId(arg2);
24725
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 Py_INCREF(Py_None); resultobj = Py_None;
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj;
24738 wxWindow *arg1 = (wxWindow *) 0 ;
24739 int result;
24740 PyObject * obj0 = 0 ;
24741 char *kwnames[] = {
24742 (char *) "self", NULL
24743 };
24744
24745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(1)) SWIG_fail;
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (int)((wxWindow const *)arg1)->GetId();
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 {
24756 resultobj = SWIG_From_int((int)(result));
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 int result;
24767 char *kwnames[] = {
24768 NULL
24769 };
24770
24771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (int)wxWindow::NewControlId();
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = SWIG_From_int((int)(result));
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 int arg1 ;
24791 int result;
24792 PyObject * obj0 = 0 ;
24793 char *kwnames[] = {
24794 (char *) "winid", NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24798 {
24799 arg1 = (int)(SWIG_As_int(obj0));
24800 if (SWIG_arg_fail(1)) SWIG_fail;
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (int)wxWindow::NextControlId(arg1);
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = SWIG_From_int((int)(result));
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24819 PyObject *resultobj;
24820 int arg1 ;
24821 int result;
24822 PyObject * obj0 = 0 ;
24823 char *kwnames[] = {
24824 (char *) "winid", NULL
24825 };
24826
24827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24828 {
24829 arg1 = (int)(SWIG_As_int(obj0));
24830 if (SWIG_arg_fail(1)) SWIG_fail;
24831 }
24832 {
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 result = (int)wxWindow::PrevControlId(arg1);
24835
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = SWIG_From_int((int)(result));
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj;
24850 wxWindow *arg1 = (wxWindow *) 0 ;
24851 wxSize *arg2 = 0 ;
24852 wxSize temp2 ;
24853 PyObject * obj0 = 0 ;
24854 PyObject * obj1 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self",(char *) "size", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 {
24863 arg2 = &temp2;
24864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 (arg1)->SetSize((wxSize const &)*arg2);
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 Py_INCREF(Py_None); resultobj = Py_None;
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxWindow *arg1 = (wxWindow *) 0 ;
24883 int arg2 ;
24884 int arg3 ;
24885 int arg4 ;
24886 int arg5 ;
24887 int arg6 = (int) wxSIZE_AUTO ;
24888 PyObject * obj0 = 0 ;
24889 PyObject * obj1 = 0 ;
24890 PyObject * obj2 = 0 ;
24891 PyObject * obj3 = 0 ;
24892 PyObject * obj4 = 0 ;
24893 PyObject * obj5 = 0 ;
24894 char *kwnames[] = {
24895 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24896 };
24897
24898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24900 if (SWIG_arg_fail(1)) SWIG_fail;
24901 {
24902 arg2 = (int)(SWIG_As_int(obj1));
24903 if (SWIG_arg_fail(2)) SWIG_fail;
24904 }
24905 {
24906 arg3 = (int)(SWIG_As_int(obj2));
24907 if (SWIG_arg_fail(3)) SWIG_fail;
24908 }
24909 {
24910 arg4 = (int)(SWIG_As_int(obj3));
24911 if (SWIG_arg_fail(4)) SWIG_fail;
24912 }
24913 {
24914 arg5 = (int)(SWIG_As_int(obj4));
24915 if (SWIG_arg_fail(5)) SWIG_fail;
24916 }
24917 if (obj5) {
24918 {
24919 arg6 = (int)(SWIG_As_int(obj5));
24920 if (SWIG_arg_fail(6)) SWIG_fail;
24921 }
24922 }
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
24926
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 Py_INCREF(Py_None); resultobj = Py_None;
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj;
24939 wxWindow *arg1 = (wxWindow *) 0 ;
24940 wxRect *arg2 = 0 ;
24941 int arg3 = (int) wxSIZE_AUTO ;
24942 wxRect temp2 ;
24943 PyObject * obj0 = 0 ;
24944 PyObject * obj1 = 0 ;
24945 PyObject * obj2 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 arg2 = &temp2;
24955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24956 }
24957 if (obj2) {
24958 {
24959 arg3 = (int)(SWIG_As_int(obj2));
24960 if (SWIG_arg_fail(3)) SWIG_fail;
24961 }
24962 }
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 (arg1)->SetSize((wxRect const &)*arg2,arg3);
24966
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 Py_INCREF(Py_None); resultobj = Py_None;
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj;
24979 wxWindow *arg1 = (wxWindow *) 0 ;
24980 int arg2 ;
24981 int arg3 ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 PyObject * obj2 = 0 ;
24985 char *kwnames[] = {
24986 (char *) "self",(char *) "width",(char *) "height", NULL
24987 };
24988
24989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
24990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24991 if (SWIG_arg_fail(1)) SWIG_fail;
24992 {
24993 arg2 = (int)(SWIG_As_int(obj1));
24994 if (SWIG_arg_fail(2)) SWIG_fail;
24995 }
24996 {
24997 arg3 = (int)(SWIG_As_int(obj2));
24998 if (SWIG_arg_fail(3)) SWIG_fail;
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 (arg1)->SetSize(arg2,arg3);
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 Py_INCREF(Py_None); resultobj = Py_None;
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj;
25016 wxWindow *arg1 = (wxWindow *) 0 ;
25017 wxPoint *arg2 = 0 ;
25018 int arg3 = (int) wxSIZE_USE_EXISTING ;
25019 wxPoint temp2 ;
25020 PyObject * obj0 = 0 ;
25021 PyObject * obj1 = 0 ;
25022 PyObject * obj2 = 0 ;
25023 char *kwnames[] = {
25024 (char *) "self",(char *) "pt",(char *) "flags", NULL
25025 };
25026
25027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25029 if (SWIG_arg_fail(1)) SWIG_fail;
25030 {
25031 arg2 = &temp2;
25032 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25033 }
25034 if (obj2) {
25035 {
25036 arg3 = (int)(SWIG_As_int(obj2));
25037 if (SWIG_arg_fail(3)) SWIG_fail;
25038 }
25039 }
25040 {
25041 PyThreadState* __tstate = wxPyBeginAllowThreads();
25042 (arg1)->Move((wxPoint const &)*arg2,arg3);
25043
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 Py_INCREF(Py_None); resultobj = Py_None;
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 wxWindow *arg1 = (wxWindow *) 0 ;
25057 int arg2 ;
25058 int arg3 ;
25059 int arg4 = (int) wxSIZE_USE_EXISTING ;
25060 PyObject * obj0 = 0 ;
25061 PyObject * obj1 = 0 ;
25062 PyObject * obj2 = 0 ;
25063 PyObject * obj3 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 arg2 = (int)(SWIG_As_int(obj1));
25073 if (SWIG_arg_fail(2)) SWIG_fail;
25074 }
25075 {
25076 arg3 = (int)(SWIG_As_int(obj2));
25077 if (SWIG_arg_fail(3)) SWIG_fail;
25078 }
25079 if (obj3) {
25080 {
25081 arg4 = (int)(SWIG_As_int(obj3));
25082 if (SWIG_arg_fail(4)) SWIG_fail;
25083 }
25084 }
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 (arg1)->Move(arg2,arg3,arg4);
25088
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 Py_INCREF(Py_None); resultobj = Py_None;
25093 return resultobj;
25094 fail:
25095 return NULL;
25096 }
25097
25098
25099 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj;
25101 wxWindow *arg1 = (wxWindow *) 0 ;
25102 wxSize const &arg2_defvalue = wxDefaultSize ;
25103 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25104 wxSize temp2 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self",(char *) "size", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 if (obj1) {
25115 {
25116 arg2 = &temp2;
25117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25118 }
25119 }
25120 {
25121 PyThreadState* __tstate = wxPyBeginAllowThreads();
25122 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25123
25124 wxPyEndAllowThreads(__tstate);
25125 if (PyErr_Occurred()) SWIG_fail;
25126 }
25127 Py_INCREF(Py_None); resultobj = Py_None;
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxWindow *arg1 = (wxWindow *) 0 ;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "self", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25144 if (SWIG_arg_fail(1)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 (arg1)->Raise();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 Py_INCREF(Py_None); resultobj = Py_None;
25153 return resultobj;
25154 fail:
25155 return NULL;
25156 }
25157
25158
25159 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25160 PyObject *resultobj;
25161 wxWindow *arg1 = (wxWindow *) 0 ;
25162 PyObject * obj0 = 0 ;
25163 char *kwnames[] = {
25164 (char *) "self", NULL
25165 };
25166
25167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25169 if (SWIG_arg_fail(1)) SWIG_fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 (arg1)->Lower();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 Py_INCREF(Py_None); resultobj = Py_None;
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj;
25186 wxWindow *arg1 = (wxWindow *) 0 ;
25187 wxSize *arg2 = 0 ;
25188 wxSize temp2 ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char *kwnames[] = {
25192 (char *) "self",(char *) "size", NULL
25193 };
25194
25195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25197 if (SWIG_arg_fail(1)) SWIG_fail;
25198 {
25199 arg2 = &temp2;
25200 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25201 }
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 (arg1)->SetClientSize((wxSize const &)*arg2);
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 Py_INCREF(Py_None); resultobj = Py_None;
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj;
25218 wxWindow *arg1 = (wxWindow *) 0 ;
25219 int arg2 ;
25220 int arg3 ;
25221 PyObject * obj0 = 0 ;
25222 PyObject * obj1 = 0 ;
25223 PyObject * obj2 = 0 ;
25224 char *kwnames[] = {
25225 (char *) "self",(char *) "width",(char *) "height", NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25230 if (SWIG_arg_fail(1)) SWIG_fail;
25231 {
25232 arg2 = (int)(SWIG_As_int(obj1));
25233 if (SWIG_arg_fail(2)) SWIG_fail;
25234 }
25235 {
25236 arg3 = (int)(SWIG_As_int(obj2));
25237 if (SWIG_arg_fail(3)) SWIG_fail;
25238 }
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 (arg1)->SetClientSize(arg2,arg3);
25242
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 Py_INCREF(Py_None); resultobj = Py_None;
25247 return resultobj;
25248 fail:
25249 return NULL;
25250 }
25251
25252
25253 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj;
25255 wxWindow *arg1 = (wxWindow *) 0 ;
25256 wxRect *arg2 = 0 ;
25257 wxRect temp2 ;
25258 PyObject * obj0 = 0 ;
25259 PyObject * obj1 = 0 ;
25260 char *kwnames[] = {
25261 (char *) "self",(char *) "rect", NULL
25262 };
25263
25264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25266 if (SWIG_arg_fail(1)) SWIG_fail;
25267 {
25268 arg2 = &temp2;
25269 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 (arg1)->SetClientSize((wxRect const &)*arg2);
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 Py_INCREF(Py_None); resultobj = Py_None;
25279 return resultobj;
25280 fail:
25281 return NULL;
25282 }
25283
25284
25285 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25286 PyObject *resultobj;
25287 wxWindow *arg1 = (wxWindow *) 0 ;
25288 wxPoint result;
25289 PyObject * obj0 = 0 ;
25290 char *kwnames[] = {
25291 (char *) "self", NULL
25292 };
25293
25294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25296 if (SWIG_arg_fail(1)) SWIG_fail;
25297 {
25298 PyThreadState* __tstate = wxPyBeginAllowThreads();
25299 result = (arg1)->GetPosition();
25300
25301 wxPyEndAllowThreads(__tstate);
25302 if (PyErr_Occurred()) SWIG_fail;
25303 }
25304 {
25305 wxPoint * resultptr;
25306 resultptr = new wxPoint((wxPoint &)(result));
25307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25308 }
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj;
25317 wxWindow *arg1 = (wxWindow *) 0 ;
25318 int *arg2 = (int *) 0 ;
25319 int *arg3 = (int *) 0 ;
25320 int temp2 ;
25321 int res2 = 0 ;
25322 int temp3 ;
25323 int res3 = 0 ;
25324 PyObject * obj0 = 0 ;
25325 char *kwnames[] = {
25326 (char *) "self", NULL
25327 };
25328
25329 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25330 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25333 if (SWIG_arg_fail(1)) SWIG_fail;
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 (arg1)->GetPosition(arg2,arg3);
25337
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 Py_INCREF(Py_None); resultobj = Py_None;
25342 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25343 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25344 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25345 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25346 return resultobj;
25347 fail:
25348 return NULL;
25349 }
25350
25351
25352 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25353 PyObject *resultobj;
25354 wxWindow *arg1 = (wxWindow *) 0 ;
25355 wxSize result;
25356 PyObject * obj0 = 0 ;
25357 char *kwnames[] = {
25358 (char *) "self", NULL
25359 };
25360
25361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25363 if (SWIG_arg_fail(1)) SWIG_fail;
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = ((wxWindow const *)arg1)->GetSize();
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 {
25372 wxSize * resultptr;
25373 resultptr = new wxSize((wxSize &)(result));
25374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25375 }
25376 return resultobj;
25377 fail:
25378 return NULL;
25379 }
25380
25381
25382 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj;
25384 wxWindow *arg1 = (wxWindow *) 0 ;
25385 int *arg2 = (int *) 0 ;
25386 int *arg3 = (int *) 0 ;
25387 int temp2 ;
25388 int res2 = 0 ;
25389 int temp3 ;
25390 int res3 = 0 ;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25397 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25400 if (SWIG_arg_fail(1)) SWIG_fail;
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25404
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 Py_INCREF(Py_None); resultobj = Py_None;
25409 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25410 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25411 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25412 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25413 return resultobj;
25414 fail:
25415 return NULL;
25416 }
25417
25418
25419 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25420 PyObject *resultobj;
25421 wxWindow *arg1 = (wxWindow *) 0 ;
25422 wxRect result;
25423 PyObject * obj0 = 0 ;
25424 char *kwnames[] = {
25425 (char *) "self", NULL
25426 };
25427
25428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25430 if (SWIG_arg_fail(1)) SWIG_fail;
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = ((wxWindow const *)arg1)->GetRect();
25434
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 {
25439 wxRect * resultptr;
25440 resultptr = new wxRect((wxRect &)(result));
25441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25442 }
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj;
25451 wxWindow *arg1 = (wxWindow *) 0 ;
25452 wxSize result;
25453 PyObject * obj0 = 0 ;
25454 char *kwnames[] = {
25455 (char *) "self", NULL
25456 };
25457
25458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25460 if (SWIG_arg_fail(1)) SWIG_fail;
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 result = ((wxWindow const *)arg1)->GetClientSize();
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 {
25469 wxSize * resultptr;
25470 resultptr = new wxSize((wxSize &)(result));
25471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25472 }
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 wxWindow *arg1 = (wxWindow *) 0 ;
25482 int *arg2 = (int *) 0 ;
25483 int *arg3 = (int *) 0 ;
25484 int temp2 ;
25485 int res2 = 0 ;
25486 int temp3 ;
25487 int res3 = 0 ;
25488 PyObject * obj0 = 0 ;
25489 char *kwnames[] = {
25490 (char *) "self", NULL
25491 };
25492
25493 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25494 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25497 if (SWIG_arg_fail(1)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 Py_INCREF(Py_None); resultobj = Py_None;
25506 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25507 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25508 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25509 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj;
25518 wxWindow *arg1 = (wxWindow *) 0 ;
25519 wxPoint result;
25520 PyObject * obj0 = 0 ;
25521 char *kwnames[] = {
25522 (char *) "self", NULL
25523 };
25524
25525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25527 if (SWIG_arg_fail(1)) SWIG_fail;
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25531
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 {
25536 wxPoint * resultptr;
25537 resultptr = new wxPoint((wxPoint &)(result));
25538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25539 }
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 wxWindow *arg1 = (wxWindow *) 0 ;
25549 wxRect result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "self", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25557 if (SWIG_arg_fail(1)) SWIG_fail;
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = ((wxWindow const *)arg1)->GetClientRect();
25561
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 {
25566 wxRect * resultptr;
25567 resultptr = new wxRect((wxRect &)(result));
25568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj;
25578 wxWindow *arg1 = (wxWindow *) 0 ;
25579 wxSize result;
25580 PyObject * obj0 = 0 ;
25581 char *kwnames[] = {
25582 (char *) "self", NULL
25583 };
25584
25585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25587 if (SWIG_arg_fail(1)) SWIG_fail;
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = ((wxWindow const *)arg1)->GetBestSize();
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 {
25596 wxSize * resultptr;
25597 resultptr = new wxSize((wxSize &)(result));
25598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxWindow *arg1 = (wxWindow *) 0 ;
25609 int *arg2 = (int *) 0 ;
25610 int *arg3 = (int *) 0 ;
25611 int temp2 ;
25612 int res2 = 0 ;
25613 int temp3 ;
25614 int res3 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 char *kwnames[] = {
25617 (char *) "self", NULL
25618 };
25619
25620 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25621 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25624 if (SWIG_arg_fail(1)) SWIG_fail;
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 Py_INCREF(Py_None); resultobj = Py_None;
25633 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25634 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25635 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25636 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 wxWindow *arg1 = (wxWindow *) 0 ;
25646 PyObject * obj0 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 (arg1)->InvalidateBestSize();
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 Py_INCREF(Py_None); resultobj = Py_None;
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj;
25670 wxWindow *arg1 = (wxWindow *) 0 ;
25671 wxSize result;
25672 PyObject * obj0 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25683
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 {
25688 wxSize * resultptr;
25689 resultptr = new wxSize((wxSize &)(result));
25690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25691 }
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj;
25700 wxWindow *arg1 = (wxWindow *) 0 ;
25701 wxSize result;
25702 PyObject * obj0 = 0 ;
25703 char *kwnames[] = {
25704 (char *) "self", NULL
25705 };
25706
25707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 {
25718 wxSize * resultptr;
25719 resultptr = new wxSize((wxSize &)(result));
25720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25721 }
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj;
25730 wxWindow *arg1 = (wxWindow *) 0 ;
25731 int arg2 = (int) wxBOTH ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "direction", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 if (obj1) {
25742 {
25743 arg2 = (int)(SWIG_As_int(obj1));
25744 if (SWIG_arg_fail(2)) SWIG_fail;
25745 }
25746 }
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 (arg1)->Center(arg2);
25750
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 Py_INCREF(Py_None); resultobj = Py_None;
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj;
25763 wxWindow *arg1 = (wxWindow *) 0 ;
25764 int arg2 = (int) wxBOTH ;
25765 PyObject * obj0 = 0 ;
25766 PyObject * obj1 = 0 ;
25767 char *kwnames[] = {
25768 (char *) "self",(char *) "dir", NULL
25769 };
25770
25771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25773 if (SWIG_arg_fail(1)) SWIG_fail;
25774 if (obj1) {
25775 {
25776 arg2 = (int)(SWIG_As_int(obj1));
25777 if (SWIG_arg_fail(2)) SWIG_fail;
25778 }
25779 }
25780 {
25781 PyThreadState* __tstate = wxPyBeginAllowThreads();
25782 (arg1)->CenterOnScreen(arg2);
25783
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 Py_INCREF(Py_None); resultobj = Py_None;
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 int arg2 = (int) wxBOTH ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char *kwnames[] = {
25801 (char *) "self",(char *) "dir", NULL
25802 };
25803
25804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25806 if (SWIG_arg_fail(1)) SWIG_fail;
25807 if (obj1) {
25808 {
25809 arg2 = (int)(SWIG_As_int(obj1));
25810 if (SWIG_arg_fail(2)) SWIG_fail;
25811 }
25812 }
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 (arg1)->CenterOnParent(arg2);
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 Py_INCREF(Py_None); resultobj = Py_None;
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj;
25829 wxWindow *arg1 = (wxWindow *) 0 ;
25830 PyObject * obj0 = 0 ;
25831 char *kwnames[] = {
25832 (char *) "self", NULL
25833 };
25834
25835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25837 if (SWIG_arg_fail(1)) SWIG_fail;
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 (arg1)->Fit();
25841
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 Py_INCREF(Py_None); resultobj = Py_None;
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj;
25854 wxWindow *arg1 = (wxWindow *) 0 ;
25855 PyObject * obj0 = 0 ;
25856 char *kwnames[] = {
25857 (char *) "self", NULL
25858 };
25859
25860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25862 if (SWIG_arg_fail(1)) SWIG_fail;
25863 {
25864 PyThreadState* __tstate = wxPyBeginAllowThreads();
25865 (arg1)->FitInside();
25866
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 Py_INCREF(Py_None); resultobj = Py_None;
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxWindow *arg1 = (wxWindow *) 0 ;
25880 int arg2 ;
25881 int arg3 ;
25882 int arg4 = (int) -1 ;
25883 int arg5 = (int) -1 ;
25884 int arg6 = (int) -1 ;
25885 int arg7 = (int) -1 ;
25886 PyObject * obj0 = 0 ;
25887 PyObject * obj1 = 0 ;
25888 PyObject * obj2 = 0 ;
25889 PyObject * obj3 = 0 ;
25890 PyObject * obj4 = 0 ;
25891 PyObject * obj5 = 0 ;
25892 PyObject * obj6 = 0 ;
25893 char *kwnames[] = {
25894 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25895 };
25896
25897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25899 if (SWIG_arg_fail(1)) SWIG_fail;
25900 {
25901 arg2 = (int)(SWIG_As_int(obj1));
25902 if (SWIG_arg_fail(2)) SWIG_fail;
25903 }
25904 {
25905 arg3 = (int)(SWIG_As_int(obj2));
25906 if (SWIG_arg_fail(3)) SWIG_fail;
25907 }
25908 if (obj3) {
25909 {
25910 arg4 = (int)(SWIG_As_int(obj3));
25911 if (SWIG_arg_fail(4)) SWIG_fail;
25912 }
25913 }
25914 if (obj4) {
25915 {
25916 arg5 = (int)(SWIG_As_int(obj4));
25917 if (SWIG_arg_fail(5)) SWIG_fail;
25918 }
25919 }
25920 if (obj5) {
25921 {
25922 arg6 = (int)(SWIG_As_int(obj5));
25923 if (SWIG_arg_fail(6)) SWIG_fail;
25924 }
25925 }
25926 if (obj6) {
25927 {
25928 arg7 = (int)(SWIG_As_int(obj6));
25929 if (SWIG_arg_fail(7)) SWIG_fail;
25930 }
25931 }
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
25935
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 Py_INCREF(Py_None); resultobj = Py_None;
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj;
25948 wxWindow *arg1 = (wxWindow *) 0 ;
25949 wxSize *arg2 = 0 ;
25950 wxSize const &arg3_defvalue = wxDefaultSize ;
25951 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
25952 wxSize const &arg4_defvalue = wxDefaultSize ;
25953 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25954 wxSize temp2 ;
25955 wxSize temp3 ;
25956 wxSize temp4 ;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 PyObject * obj2 = 0 ;
25960 PyObject * obj3 = 0 ;
25961 char *kwnames[] = {
25962 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
25963 };
25964
25965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25967 if (SWIG_arg_fail(1)) SWIG_fail;
25968 {
25969 arg2 = &temp2;
25970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25971 }
25972 if (obj2) {
25973 {
25974 arg3 = &temp3;
25975 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
25976 }
25977 }
25978 if (obj3) {
25979 {
25980 arg4 = &temp4;
25981 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25982 }
25983 }
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
25987
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 Py_INCREF(Py_None); resultobj = Py_None;
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxWindow *arg1 = (wxWindow *) 0 ;
26001 int arg2 ;
26002 int arg3 ;
26003 int arg4 = (int) -1 ;
26004 int arg5 = (int) -1 ;
26005 PyObject * obj0 = 0 ;
26006 PyObject * obj1 = 0 ;
26007 PyObject * obj2 = 0 ;
26008 PyObject * obj3 = 0 ;
26009 PyObject * obj4 = 0 ;
26010 char *kwnames[] = {
26011 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26012 };
26013
26014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26016 if (SWIG_arg_fail(1)) SWIG_fail;
26017 {
26018 arg2 = (int)(SWIG_As_int(obj1));
26019 if (SWIG_arg_fail(2)) SWIG_fail;
26020 }
26021 {
26022 arg3 = (int)(SWIG_As_int(obj2));
26023 if (SWIG_arg_fail(3)) SWIG_fail;
26024 }
26025 if (obj3) {
26026 {
26027 arg4 = (int)(SWIG_As_int(obj3));
26028 if (SWIG_arg_fail(4)) SWIG_fail;
26029 }
26030 }
26031 if (obj4) {
26032 {
26033 arg5 = (int)(SWIG_As_int(obj4));
26034 if (SWIG_arg_fail(5)) SWIG_fail;
26035 }
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26040
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 Py_INCREF(Py_None); resultobj = Py_None;
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj;
26053 wxWindow *arg1 = (wxWindow *) 0 ;
26054 wxSize *arg2 = 0 ;
26055 wxSize const &arg3_defvalue = wxDefaultSize ;
26056 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26057 wxSize temp2 ;
26058 wxSize temp3 ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 PyObject * obj2 = 0 ;
26062 char *kwnames[] = {
26063 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26064 };
26065
26066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26068 if (SWIG_arg_fail(1)) SWIG_fail;
26069 {
26070 arg2 = &temp2;
26071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26072 }
26073 if (obj2) {
26074 {
26075 arg3 = &temp3;
26076 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26082
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 Py_INCREF(Py_None); resultobj = Py_None;
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 wxWindow *arg1 = (wxWindow *) 0 ;
26096 wxSize result;
26097 PyObject * obj0 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 result = ((wxWindow const *)arg1)->GetMaxSize();
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 {
26113 wxSize * resultptr;
26114 resultptr = new wxSize((wxSize &)(result));
26115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26116 }
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj;
26125 wxWindow *arg1 = (wxWindow *) 0 ;
26126 wxSize result;
26127 PyObject * obj0 = 0 ;
26128 char *kwnames[] = {
26129 (char *) "self", NULL
26130 };
26131
26132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26134 if (SWIG_arg_fail(1)) SWIG_fail;
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 result = ((wxWindow const *)arg1)->GetMinSize();
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 {
26143 wxSize * resultptr;
26144 resultptr = new wxSize((wxSize &)(result));
26145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26146 }
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj;
26155 wxWindow *arg1 = (wxWindow *) 0 ;
26156 wxSize *arg2 = 0 ;
26157 wxSize temp2 ;
26158 PyObject * obj0 = 0 ;
26159 PyObject * obj1 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "minSize", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 arg2 = &temp2;
26169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26170 }
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 (arg1)->SetMinSize((wxSize const &)*arg2);
26174
26175 wxPyEndAllowThreads(__tstate);
26176 if (PyErr_Occurred()) SWIG_fail;
26177 }
26178 Py_INCREF(Py_None); resultobj = Py_None;
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj;
26187 wxWindow *arg1 = (wxWindow *) 0 ;
26188 wxSize *arg2 = 0 ;
26189 wxSize temp2 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char *kwnames[] = {
26193 (char *) "self",(char *) "maxSize", NULL
26194 };
26195
26196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 {
26200 arg2 = &temp2;
26201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26202 }
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 (arg1)->SetMaxSize((wxSize const &)*arg2);
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 Py_INCREF(Py_None); resultobj = Py_None;
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj;
26219 wxWindow *arg1 = (wxWindow *) 0 ;
26220 int result;
26221 PyObject * obj0 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26232
26233 wxPyEndAllowThreads(__tstate);
26234 if (PyErr_Occurred()) SWIG_fail;
26235 }
26236 {
26237 resultobj = SWIG_From_int((int)(result));
26238 }
26239 return resultobj;
26240 fail:
26241 return NULL;
26242 }
26243
26244
26245 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26246 PyObject *resultobj;
26247 wxWindow *arg1 = (wxWindow *) 0 ;
26248 int result;
26249 PyObject * obj0 = 0 ;
26250 char *kwnames[] = {
26251 (char *) "self", NULL
26252 };
26253
26254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26256 if (SWIG_arg_fail(1)) SWIG_fail;
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26260
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 {
26265 resultobj = SWIG_From_int((int)(result));
26266 }
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj;
26275 wxWindow *arg1 = (wxWindow *) 0 ;
26276 int result;
26277 PyObject * obj0 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self", NULL
26280 };
26281
26282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26284 if (SWIG_arg_fail(1)) SWIG_fail;
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 {
26293 resultobj = SWIG_From_int((int)(result));
26294 }
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26302 PyObject *resultobj;
26303 wxWindow *arg1 = (wxWindow *) 0 ;
26304 int result;
26305 PyObject * obj0 = 0 ;
26306 char *kwnames[] = {
26307 (char *) "self", NULL
26308 };
26309
26310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26312 if (SWIG_arg_fail(1)) SWIG_fail;
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26316
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 {
26321 resultobj = SWIG_From_int((int)(result));
26322 }
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26330 PyObject *resultobj;
26331 wxWindow *arg1 = (wxWindow *) 0 ;
26332 wxSize *arg2 = 0 ;
26333 wxSize temp2 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char *kwnames[] = {
26337 (char *) "self",(char *) "size", NULL
26338 };
26339
26340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26342 if (SWIG_arg_fail(1)) SWIG_fail;
26343 {
26344 arg2 = &temp2;
26345 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26346 }
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26350
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 Py_INCREF(Py_None); resultobj = Py_None;
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26362 PyObject *resultobj;
26363 wxWindow *arg1 = (wxWindow *) 0 ;
26364 int arg2 ;
26365 int arg3 ;
26366 PyObject * obj0 = 0 ;
26367 PyObject * obj1 = 0 ;
26368 PyObject * obj2 = 0 ;
26369 char *kwnames[] = {
26370 (char *) "self",(char *) "w",(char *) "h", NULL
26371 };
26372
26373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26375 if (SWIG_arg_fail(1)) SWIG_fail;
26376 {
26377 arg2 = (int)(SWIG_As_int(obj1));
26378 if (SWIG_arg_fail(2)) SWIG_fail;
26379 }
26380 {
26381 arg3 = (int)(SWIG_As_int(obj2));
26382 if (SWIG_arg_fail(3)) SWIG_fail;
26383 }
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 (arg1)->SetVirtualSize(arg2,arg3);
26387
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 Py_INCREF(Py_None); resultobj = Py_None;
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26399 PyObject *resultobj;
26400 wxWindow *arg1 = (wxWindow *) 0 ;
26401 wxSize result;
26402 PyObject * obj0 = 0 ;
26403 char *kwnames[] = {
26404 (char *) "self", NULL
26405 };
26406
26407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26409 if (SWIG_arg_fail(1)) SWIG_fail;
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = ((wxWindow const *)arg1)->GetVirtualSize();
26413
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 {
26418 wxSize * resultptr;
26419 resultptr = new wxSize((wxSize &)(result));
26420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26421 }
26422 return resultobj;
26423 fail:
26424 return NULL;
26425 }
26426
26427
26428 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26429 PyObject *resultobj;
26430 wxWindow *arg1 = (wxWindow *) 0 ;
26431 int *arg2 = (int *) 0 ;
26432 int *arg3 = (int *) 0 ;
26433 int temp2 ;
26434 int res2 = 0 ;
26435 int temp3 ;
26436 int res3 = 0 ;
26437 PyObject * obj0 = 0 ;
26438 char *kwnames[] = {
26439 (char *) "self", NULL
26440 };
26441
26442 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26443 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26446 if (SWIG_arg_fail(1)) SWIG_fail;
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26450
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 Py_INCREF(Py_None); resultobj = Py_None;
26455 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26456 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26457 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26458 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj;
26467 wxWindow *arg1 = (wxWindow *) 0 ;
26468 wxSize result;
26469 PyObject * obj0 = 0 ;
26470 char *kwnames[] = {
26471 (char *) "self", NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26480
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 {
26485 wxSize * resultptr;
26486 resultptr = new wxSize((wxSize &)(result));
26487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26488 }
26489 return resultobj;
26490 fail:
26491 return NULL;
26492 }
26493
26494
26495 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26496 PyObject *resultobj;
26497 wxWindow *arg1 = (wxWindow *) 0 ;
26498 bool arg2 = (bool) true ;
26499 bool result;
26500 PyObject * obj0 = 0 ;
26501 PyObject * obj1 = 0 ;
26502 char *kwnames[] = {
26503 (char *) "self",(char *) "show", NULL
26504 };
26505
26506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26508 if (SWIG_arg_fail(1)) SWIG_fail;
26509 if (obj1) {
26510 {
26511 arg2 = (bool)(SWIG_As_bool(obj1));
26512 if (SWIG_arg_fail(2)) SWIG_fail;
26513 }
26514 }
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 result = (bool)(arg1)->Show(arg2);
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 {
26523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26524 }
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj;
26533 wxWindow *arg1 = (wxWindow *) 0 ;
26534 bool result;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "self", NULL
26538 };
26539
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 result = (bool)(arg1)->Hide();
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 {
26551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 bool arg2 = (bool) true ;
26563 bool result;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self",(char *) "enable", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 if (obj1) {
26574 {
26575 arg2 = (bool)(SWIG_As_bool(obj1));
26576 if (SWIG_arg_fail(2)) SWIG_fail;
26577 }
26578 }
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 result = (bool)(arg1)->Enable(arg2);
26582
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 {
26587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26588 }
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj;
26597 wxWindow *arg1 = (wxWindow *) 0 ;
26598 bool result;
26599 PyObject * obj0 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (bool)(arg1)->Disable();
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 bool result;
26627 PyObject * obj0 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26634 if (SWIG_arg_fail(1)) SWIG_fail;
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (bool)((wxWindow const *)arg1)->IsShown();
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26644 }
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 bool result;
26655 PyObject * obj0 = 0 ;
26656 char *kwnames[] = {
26657 (char *) "self", NULL
26658 };
26659
26660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26662 if (SWIG_arg_fail(1)) SWIG_fail;
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26666
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj;
26681 wxWindow *arg1 = (wxWindow *) 0 ;
26682 long arg2 ;
26683 PyObject * obj0 = 0 ;
26684 PyObject * obj1 = 0 ;
26685 char *kwnames[] = {
26686 (char *) "self",(char *) "style", NULL
26687 };
26688
26689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26691 if (SWIG_arg_fail(1)) SWIG_fail;
26692 {
26693 arg2 = (long)(SWIG_As_long(obj1));
26694 if (SWIG_arg_fail(2)) SWIG_fail;
26695 }
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 (arg1)->SetWindowStyleFlag(arg2);
26699
26700 wxPyEndAllowThreads(__tstate);
26701 if (PyErr_Occurred()) SWIG_fail;
26702 }
26703 Py_INCREF(Py_None); resultobj = Py_None;
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj;
26712 wxWindow *arg1 = (wxWindow *) 0 ;
26713 long result;
26714 PyObject * obj0 = 0 ;
26715 char *kwnames[] = {
26716 (char *) "self", NULL
26717 };
26718
26719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26721 if (SWIG_arg_fail(1)) SWIG_fail;
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26725
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 {
26730 resultobj = SWIG_From_long((long)(result));
26731 }
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj;
26740 wxWindow *arg1 = (wxWindow *) 0 ;
26741 int arg2 ;
26742 bool result;
26743 PyObject * obj0 = 0 ;
26744 PyObject * obj1 = 0 ;
26745 char *kwnames[] = {
26746 (char *) "self",(char *) "flag", NULL
26747 };
26748
26749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26751 if (SWIG_arg_fail(1)) SWIG_fail;
26752 {
26753 arg2 = (int)(SWIG_As_int(obj1));
26754 if (SWIG_arg_fail(2)) SWIG_fail;
26755 }
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26759
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 {
26764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26765 }
26766 return resultobj;
26767 fail:
26768 return NULL;
26769 }
26770
26771
26772 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26773 PyObject *resultobj;
26774 wxWindow *arg1 = (wxWindow *) 0 ;
26775 bool result;
26776 PyObject * obj0 = 0 ;
26777 char *kwnames[] = {
26778 (char *) "self", NULL
26779 };
26780
26781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26783 if (SWIG_arg_fail(1)) SWIG_fail;
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (bool)((wxWindow const *)arg1)->IsRetained();
26787
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 {
26792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793 }
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj;
26802 wxWindow *arg1 = (wxWindow *) 0 ;
26803 long arg2 ;
26804 PyObject * obj0 = 0 ;
26805 PyObject * obj1 = 0 ;
26806 char *kwnames[] = {
26807 (char *) "self",(char *) "exStyle", NULL
26808 };
26809
26810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26812 if (SWIG_arg_fail(1)) SWIG_fail;
26813 {
26814 arg2 = (long)(SWIG_As_long(obj1));
26815 if (SWIG_arg_fail(2)) SWIG_fail;
26816 }
26817 {
26818 PyThreadState* __tstate = wxPyBeginAllowThreads();
26819 (arg1)->SetExtraStyle(arg2);
26820
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 Py_INCREF(Py_None); resultobj = Py_None;
26825 return resultobj;
26826 fail:
26827 return NULL;
26828 }
26829
26830
26831 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26832 PyObject *resultobj;
26833 wxWindow *arg1 = (wxWindow *) 0 ;
26834 long result;
26835 PyObject * obj0 = 0 ;
26836 char *kwnames[] = {
26837 (char *) "self", NULL
26838 };
26839
26840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26842 if (SWIG_arg_fail(1)) SWIG_fail;
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26846
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 {
26851 resultobj = SWIG_From_long((long)(result));
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 bool arg2 = (bool) true ;
26863 PyObject * obj0 = 0 ;
26864 PyObject * obj1 = 0 ;
26865 char *kwnames[] = {
26866 (char *) "self",(char *) "modal", NULL
26867 };
26868
26869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26871 if (SWIG_arg_fail(1)) SWIG_fail;
26872 if (obj1) {
26873 {
26874 arg2 = (bool)(SWIG_As_bool(obj1));
26875 if (SWIG_arg_fail(2)) SWIG_fail;
26876 }
26877 }
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 (arg1)->MakeModal(arg2);
26881
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 Py_INCREF(Py_None); resultobj = Py_None;
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxWindow *arg1 = (wxWindow *) 0 ;
26895 bool arg2 ;
26896 PyObject * obj0 = 0 ;
26897 PyObject * obj1 = 0 ;
26898 char *kwnames[] = {
26899 (char *) "self",(char *) "enableTheme", NULL
26900 };
26901
26902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26904 if (SWIG_arg_fail(1)) SWIG_fail;
26905 {
26906 arg2 = (bool)(SWIG_As_bool(obj1));
26907 if (SWIG_arg_fail(2)) SWIG_fail;
26908 }
26909 {
26910 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 (arg1)->SetThemeEnabled(arg2);
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 Py_INCREF(Py_None); resultobj = Py_None;
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxWindow *arg1 = (wxWindow *) 0 ;
26926 bool result;
26927 PyObject * obj0 = 0 ;
26928 char *kwnames[] = {
26929 (char *) "self", NULL
26930 };
26931
26932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
26933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26934 if (SWIG_arg_fail(1)) SWIG_fail;
26935 {
26936 PyThreadState* __tstate = wxPyBeginAllowThreads();
26937 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
26938
26939 wxPyEndAllowThreads(__tstate);
26940 if (PyErr_Occurred()) SWIG_fail;
26941 }
26942 {
26943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26944 }
26945 return resultobj;
26946 fail:
26947 return NULL;
26948 }
26949
26950
26951 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj;
26953 wxWindow *arg1 = (wxWindow *) 0 ;
26954 PyObject * obj0 = 0 ;
26955 char *kwnames[] = {
26956 (char *) "self", NULL
26957 };
26958
26959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
26960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26961 if (SWIG_arg_fail(1)) SWIG_fail;
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 (arg1)->SetFocus();
26965
26966 wxPyEndAllowThreads(__tstate);
26967 if (PyErr_Occurred()) SWIG_fail;
26968 }
26969 Py_INCREF(Py_None); resultobj = Py_None;
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj;
26978 wxWindow *arg1 = (wxWindow *) 0 ;
26979 PyObject * obj0 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 (arg1)->SetFocusFromKbd();
26990
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 Py_INCREF(Py_None); resultobj = Py_None;
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj;
27003 wxWindow *result;
27004 char *kwnames[] = {
27005 NULL
27006 };
27007
27008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27009 {
27010 if (!wxPyCheckForApp()) SWIG_fail;
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 result = (wxWindow *)wxWindow::FindFocus();
27013
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 {
27018 resultobj = wxPyMake_wxObject(result, 0);
27019 }
27020 return resultobj;
27021 fail:
27022 return NULL;
27023 }
27024
27025
27026 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27027 PyObject *resultobj;
27028 wxWindow *arg1 = (wxWindow *) 0 ;
27029 bool result;
27030 PyObject * obj0 = 0 ;
27031 char *kwnames[] = {
27032 (char *) "self", NULL
27033 };
27034
27035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27041
27042 wxPyEndAllowThreads(__tstate);
27043 if (PyErr_Occurred()) SWIG_fail;
27044 }
27045 {
27046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27047 }
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27055 PyObject *resultobj;
27056 wxWindow *arg1 = (wxWindow *) 0 ;
27057 bool result;
27058 PyObject * obj0 = 0 ;
27059 char *kwnames[] = {
27060 (char *) "self", NULL
27061 };
27062
27063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27065 if (SWIG_arg_fail(1)) SWIG_fail;
27066 {
27067 PyThreadState* __tstate = wxPyBeginAllowThreads();
27068 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27069
27070 wxPyEndAllowThreads(__tstate);
27071 if (PyErr_Occurred()) SWIG_fail;
27072 }
27073 {
27074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27075 }
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj;
27084 wxWindow *arg1 = (wxWindow *) 0 ;
27085 wxWindow *result;
27086 PyObject * obj0 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 {
27095 PyThreadState* __tstate = wxPyBeginAllowThreads();
27096 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27097
27098 wxPyEndAllowThreads(__tstate);
27099 if (PyErr_Occurred()) SWIG_fail;
27100 }
27101 {
27102 resultobj = wxPyMake_wxObject(result, 0);
27103 }
27104 return resultobj;
27105 fail:
27106 return NULL;
27107 }
27108
27109
27110 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27111 PyObject *resultobj;
27112 wxWindow *arg1 = (wxWindow *) 0 ;
27113 wxWindow *arg2 = (wxWindow *) 0 ;
27114 wxWindow *result;
27115 PyObject * obj0 = 0 ;
27116 PyObject * obj1 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self",(char *) "child", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27125 if (SWIG_arg_fail(2)) SWIG_fail;
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 {
27134 resultobj = wxPyMake_wxObject(result, 0);
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj;
27144 wxWindow *arg1 = (wxWindow *) 0 ;
27145 wxWindow *arg2 = (wxWindow *) 0 ;
27146 PyObject * obj0 = 0 ;
27147 PyObject * obj1 = 0 ;
27148 char *kwnames[] = {
27149 (char *) "self",(char *) "win", NULL
27150 };
27151
27152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27154 if (SWIG_arg_fail(1)) SWIG_fail;
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 (arg1)->SetTmpDefaultItem(arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 Py_INCREF(Py_None); resultobj = Py_None;
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj;
27173 wxWindow *arg1 = (wxWindow *) 0 ;
27174 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27175 bool result;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self",(char *) "flags", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 if (obj1) {
27186 {
27187 arg2 = (int)(SWIG_As_int(obj1));
27188 if (SWIG_arg_fail(2)) SWIG_fail;
27189 }
27190 }
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 result = (bool)(arg1)->Navigate(arg2);
27194
27195 wxPyEndAllowThreads(__tstate);
27196 if (PyErr_Occurred()) SWIG_fail;
27197 }
27198 {
27199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27200 }
27201 return resultobj;
27202 fail:
27203 return NULL;
27204 }
27205
27206
27207 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27208 PyObject *resultobj;
27209 wxWindow *arg1 = (wxWindow *) 0 ;
27210 wxWindow *arg2 = (wxWindow *) 0 ;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "win", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->MoveAfterInTabOrder(arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 Py_INCREF(Py_None); resultobj = Py_None;
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj;
27238 wxWindow *arg1 = (wxWindow *) 0 ;
27239 wxWindow *arg2 = (wxWindow *) 0 ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self",(char *) "win", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->MoveBeforeInTabOrder(arg2);
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 Py_INCREF(Py_None); resultobj = Py_None;
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 PyObject *result;
27269 PyObject * obj0 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (PyObject *)wxWindow_GetChildren(arg1);
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = result;
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27292 PyObject *resultobj;
27293 wxWindow *arg1 = (wxWindow *) 0 ;
27294 wxWindow *result;
27295 PyObject * obj0 = 0 ;
27296 char *kwnames[] = {
27297 (char *) "self", NULL
27298 };
27299
27300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27302 if (SWIG_arg_fail(1)) SWIG_fail;
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 {
27311 resultobj = wxPyMake_wxObject(result, 0);
27312 }
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj;
27321 wxWindow *arg1 = (wxWindow *) 0 ;
27322 wxWindow *result;
27323 PyObject * obj0 = 0 ;
27324 char *kwnames[] = {
27325 (char *) "self", NULL
27326 };
27327
27328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27330 if (SWIG_arg_fail(1)) SWIG_fail;
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27334
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 {
27339 resultobj = wxPyMake_wxObject(result, 0);
27340 }
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj;
27349 wxWindow *arg1 = (wxWindow *) 0 ;
27350 bool result;
27351 PyObject * obj0 = 0 ;
27352 char *kwnames[] = {
27353 (char *) "self", NULL
27354 };
27355
27356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27362
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27368 }
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj;
27377 wxWindow *arg1 = (wxWindow *) 0 ;
27378 wxWindow *arg2 = (wxWindow *) 0 ;
27379 bool result;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char *kwnames[] = {
27383 (char *) "self",(char *) "newParent", NULL
27384 };
27385
27386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(1)) SWIG_fail;
27389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27390 if (SWIG_arg_fail(2)) SWIG_fail;
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = (bool)(arg1)->Reparent(arg2);
27394
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 {
27399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27400 }
27401 return resultobj;
27402 fail:
27403 return NULL;
27404 }
27405
27406
27407 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj;
27409 wxWindow *arg1 = (wxWindow *) 0 ;
27410 wxWindow *arg2 = (wxWindow *) 0 ;
27411 PyObject * obj0 = 0 ;
27412 PyObject * obj1 = 0 ;
27413 char *kwnames[] = {
27414 (char *) "self",(char *) "child", NULL
27415 };
27416
27417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27419 if (SWIG_arg_fail(1)) SWIG_fail;
27420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(2)) SWIG_fail;
27422 {
27423 PyThreadState* __tstate = wxPyBeginAllowThreads();
27424 (arg1)->AddChild(arg2);
27425
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 Py_INCREF(Py_None); resultobj = Py_None;
27430 return resultobj;
27431 fail:
27432 return NULL;
27433 }
27434
27435
27436 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27437 PyObject *resultobj;
27438 wxWindow *arg1 = (wxWindow *) 0 ;
27439 wxWindow *arg2 = (wxWindow *) 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char *kwnames[] = {
27443 (char *) "self",(char *) "child", NULL
27444 };
27445
27446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27448 if (SWIG_arg_fail(1)) SWIG_fail;
27449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27450 if (SWIG_arg_fail(2)) SWIG_fail;
27451 {
27452 PyThreadState* __tstate = wxPyBeginAllowThreads();
27453 (arg1)->RemoveChild(arg2);
27454
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 Py_INCREF(Py_None); resultobj = Py_None;
27459 return resultobj;
27460 fail:
27461 return NULL;
27462 }
27463
27464
27465 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27466 PyObject *resultobj;
27467 wxWindow *arg1 = (wxWindow *) 0 ;
27468 long arg2 ;
27469 wxWindow *result;
27470 PyObject * obj0 = 0 ;
27471 PyObject * obj1 = 0 ;
27472 char *kwnames[] = {
27473 (char *) "self",(char *) "winid", NULL
27474 };
27475
27476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27478 if (SWIG_arg_fail(1)) SWIG_fail;
27479 {
27480 arg2 = (long)(SWIG_As_long(obj1));
27481 if (SWIG_arg_fail(2)) SWIG_fail;
27482 }
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (wxWindow *)(arg1)->FindWindow(arg2);
27486
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 {
27491 resultobj = wxPyMake_wxObject(result, 0);
27492 }
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27500 PyObject *resultobj;
27501 wxWindow *arg1 = (wxWindow *) 0 ;
27502 wxString *arg2 = 0 ;
27503 wxWindow *result;
27504 bool temp2 = false ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "name", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
27516 if (arg2 == NULL) SWIG_fail;
27517 temp2 = true;
27518 }
27519 {
27520 PyThreadState* __tstate = wxPyBeginAllowThreads();
27521 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27522
27523 wxPyEndAllowThreads(__tstate);
27524 if (PyErr_Occurred()) SWIG_fail;
27525 }
27526 {
27527 resultobj = wxPyMake_wxObject(result, 0);
27528 }
27529 {
27530 if (temp2)
27531 delete arg2;
27532 }
27533 return resultobj;
27534 fail:
27535 {
27536 if (temp2)
27537 delete arg2;
27538 }
27539 return NULL;
27540 }
27541
27542
27543 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27544 PyObject *resultobj;
27545 wxWindow *arg1 = (wxWindow *) 0 ;
27546 wxEvtHandler *result;
27547 PyObject * obj0 = 0 ;
27548 char *kwnames[] = {
27549 (char *) "self", NULL
27550 };
27551
27552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27554 if (SWIG_arg_fail(1)) SWIG_fail;
27555 {
27556 PyThreadState* __tstate = wxPyBeginAllowThreads();
27557 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27558
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = wxPyMake_wxObject(result, 0);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj;
27573 wxWindow *arg1 = (wxWindow *) 0 ;
27574 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27575 PyObject * obj0 = 0 ;
27576 PyObject * obj1 = 0 ;
27577 char *kwnames[] = {
27578 (char *) "self",(char *) "handler", NULL
27579 };
27580
27581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27583 if (SWIG_arg_fail(1)) SWIG_fail;
27584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(2)) SWIG_fail;
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 (arg1)->SetEventHandler(arg2);
27589
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 Py_INCREF(Py_None); resultobj = Py_None;
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxWindow *arg1 = (wxWindow *) 0 ;
27603 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27604 PyObject * obj0 = 0 ;
27605 PyObject * obj1 = 0 ;
27606 char *kwnames[] = {
27607 (char *) "self",(char *) "handler", NULL
27608 };
27609
27610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27612 if (SWIG_arg_fail(1)) SWIG_fail;
27613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(2)) SWIG_fail;
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 (arg1)->PushEventHandler(arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 Py_INCREF(Py_None); resultobj = Py_None;
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxWindow *arg1 = (wxWindow *) 0 ;
27632 bool arg2 = (bool) false ;
27633 wxEvtHandler *result;
27634 PyObject * obj0 = 0 ;
27635 PyObject * obj1 = 0 ;
27636 char *kwnames[] = {
27637 (char *) "self",(char *) "deleteHandler", NULL
27638 };
27639
27640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27642 if (SWIG_arg_fail(1)) SWIG_fail;
27643 if (obj1) {
27644 {
27645 arg2 = (bool)(SWIG_As_bool(obj1));
27646 if (SWIG_arg_fail(2)) SWIG_fail;
27647 }
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27652
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 {
27657 resultobj = wxPyMake_wxObject(result, 0);
27658 }
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxWindow *arg1 = (wxWindow *) 0 ;
27668 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27669 bool result;
27670 PyObject * obj0 = 0 ;
27671 PyObject * obj1 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self",(char *) "handler", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27680 if (SWIG_arg_fail(2)) SWIG_fail;
27681 {
27682 PyThreadState* __tstate = wxPyBeginAllowThreads();
27683 result = (bool)(arg1)->RemoveEventHandler(arg2);
27684
27685 wxPyEndAllowThreads(__tstate);
27686 if (PyErr_Occurred()) SWIG_fail;
27687 }
27688 {
27689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27690 }
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 wxValidator *arg2 = 0 ;
27701 PyObject * obj0 = 0 ;
27702 PyObject * obj1 = 0 ;
27703 char *kwnames[] = {
27704 (char *) "self",(char *) "validator", NULL
27705 };
27706
27707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27709 if (SWIG_arg_fail(1)) SWIG_fail;
27710 {
27711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27712 if (SWIG_arg_fail(2)) SWIG_fail;
27713 if (arg2 == NULL) {
27714 SWIG_null_ref("wxValidator");
27715 }
27716 if (SWIG_arg_fail(2)) SWIG_fail;
27717 }
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 (arg1)->SetValidator((wxValidator const &)*arg2);
27721
27722 wxPyEndAllowThreads(__tstate);
27723 if (PyErr_Occurred()) SWIG_fail;
27724 }
27725 Py_INCREF(Py_None); resultobj = Py_None;
27726 return resultobj;
27727 fail:
27728 return NULL;
27729 }
27730
27731
27732 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27733 PyObject *resultobj;
27734 wxWindow *arg1 = (wxWindow *) 0 ;
27735 wxValidator *result;
27736 PyObject * obj0 = 0 ;
27737 char *kwnames[] = {
27738 (char *) "self", NULL
27739 };
27740
27741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27743 if (SWIG_arg_fail(1)) SWIG_fail;
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = (wxValidator *)(arg1)->GetValidator();
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = wxPyMake_wxObject(result, 0);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj;
27762 wxWindow *arg1 = (wxWindow *) 0 ;
27763 bool result;
27764 PyObject * obj0 = 0 ;
27765 char *kwnames[] = {
27766 (char *) "self", NULL
27767 };
27768
27769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = (bool)(arg1)->Validate();
27775
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 {
27780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27781 }
27782 return resultobj;
27783 fail:
27784 return NULL;
27785 }
27786
27787
27788 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27789 PyObject *resultobj;
27790 wxWindow *arg1 = (wxWindow *) 0 ;
27791 bool result;
27792 PyObject * obj0 = 0 ;
27793 char *kwnames[] = {
27794 (char *) "self", NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27799 if (SWIG_arg_fail(1)) SWIG_fail;
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 result = (bool)(arg1)->TransferDataToWindow();
27803
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj;
27818 wxWindow *arg1 = (wxWindow *) 0 ;
27819 bool result;
27820 PyObject * obj0 = 0 ;
27821 char *kwnames[] = {
27822 (char *) "self", NULL
27823 };
27824
27825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(1)) SWIG_fail;
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (bool)(arg1)->TransferDataFromWindow();
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj;
27846 wxWindow *arg1 = (wxWindow *) 0 ;
27847 PyObject * obj0 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27854 if (SWIG_arg_fail(1)) SWIG_fail;
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 (arg1)->InitDialog();
27858
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 Py_INCREF(Py_None); resultobj = Py_None;
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj;
27871 wxWindow *arg1 = (wxWindow *) 0 ;
27872 wxAcceleratorTable *arg2 = 0 ;
27873 PyObject * obj0 = 0 ;
27874 PyObject * obj1 = 0 ;
27875 char *kwnames[] = {
27876 (char *) "self",(char *) "accel", NULL
27877 };
27878
27879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27881 if (SWIG_arg_fail(1)) SWIG_fail;
27882 {
27883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27884 if (SWIG_arg_fail(2)) SWIG_fail;
27885 if (arg2 == NULL) {
27886 SWIG_null_ref("wxAcceleratorTable");
27887 }
27888 if (SWIG_arg_fail(2)) SWIG_fail;
27889 }
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27893
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 Py_INCREF(Py_None); resultobj = Py_None;
27898 return resultobj;
27899 fail:
27900 return NULL;
27901 }
27902
27903
27904 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27905 PyObject *resultobj;
27906 wxWindow *arg1 = (wxWindow *) 0 ;
27907 wxAcceleratorTable *result;
27908 PyObject * obj0 = 0 ;
27909 char *kwnames[] = {
27910 (char *) "self", NULL
27911 };
27912
27913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
27914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27915 if (SWIG_arg_fail(1)) SWIG_fail;
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
27919
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj;
27932 wxWindow *arg1 = (wxWindow *) 0 ;
27933 int arg2 ;
27934 int arg3 ;
27935 int arg4 ;
27936 bool result;
27937 PyObject * obj0 = 0 ;
27938 PyObject * obj1 = 0 ;
27939 PyObject * obj2 = 0 ;
27940 PyObject * obj3 = 0 ;
27941 char *kwnames[] = {
27942 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
27943 };
27944
27945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27947 if (SWIG_arg_fail(1)) SWIG_fail;
27948 {
27949 arg2 = (int)(SWIG_As_int(obj1));
27950 if (SWIG_arg_fail(2)) SWIG_fail;
27951 }
27952 {
27953 arg3 = (int)(SWIG_As_int(obj2));
27954 if (SWIG_arg_fail(3)) SWIG_fail;
27955 }
27956 {
27957 arg4 = (int)(SWIG_As_int(obj3));
27958 if (SWIG_arg_fail(4)) SWIG_fail;
27959 }
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj;
27978 wxWindow *arg1 = (wxWindow *) 0 ;
27979 int arg2 ;
27980 bool result;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "hotkeyId", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 {
27991 arg2 = (int)(SWIG_As_int(obj1));
27992 if (SWIG_arg_fail(2)) SWIG_fail;
27993 }
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 wxPoint *arg2 = 0 ;
28014 wxPoint result;
28015 wxPoint temp2 ;
28016 PyObject * obj0 = 0 ;
28017 PyObject * obj1 = 0 ;
28018 char *kwnames[] = {
28019 (char *) "self",(char *) "pt", NULL
28020 };
28021
28022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28024 if (SWIG_arg_fail(1)) SWIG_fail;
28025 {
28026 arg2 = &temp2;
28027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28028 }
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28032
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 wxPoint * resultptr;
28038 resultptr = new wxPoint((wxPoint &)(result));
28039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28040 }
28041 return resultobj;
28042 fail:
28043 return NULL;
28044 }
28045
28046
28047 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28048 PyObject *resultobj;
28049 wxWindow *arg1 = (wxWindow *) 0 ;
28050 wxSize *arg2 = 0 ;
28051 wxSize result;
28052 wxSize temp2 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "sz", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 {
28063 arg2 = &temp2;
28064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28065 }
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 {
28074 wxSize * resultptr;
28075 resultptr = new wxSize((wxSize &)(result));
28076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28077 }
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj;
28086 wxWindow *arg1 = (wxWindow *) 0 ;
28087 wxPoint *arg2 = 0 ;
28088 wxPoint result;
28089 wxPoint temp2 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char *kwnames[] = {
28093 (char *) "self",(char *) "pt", NULL
28094 };
28095
28096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28098 if (SWIG_arg_fail(1)) SWIG_fail;
28099 {
28100 arg2 = &temp2;
28101 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28102 }
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 wxPoint * resultptr;
28112 resultptr = new wxPoint((wxPoint &)(result));
28113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj;
28123 wxWindow *arg1 = (wxWindow *) 0 ;
28124 wxSize *arg2 = 0 ;
28125 wxSize result;
28126 wxSize temp2 ;
28127 PyObject * obj0 = 0 ;
28128 PyObject * obj1 = 0 ;
28129 char *kwnames[] = {
28130 (char *) "self",(char *) "sz", NULL
28131 };
28132
28133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28135 if (SWIG_arg_fail(1)) SWIG_fail;
28136 {
28137 arg2 = &temp2;
28138 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28139 }
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 {
28148 wxSize * resultptr;
28149 resultptr = new wxSize((wxSize &)(result));
28150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28151 }
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28159 PyObject *resultobj;
28160 wxWindow *arg1 = (wxWindow *) 0 ;
28161 wxPoint *arg2 = 0 ;
28162 wxPoint result;
28163 wxPoint temp2 ;
28164 PyObject * obj0 = 0 ;
28165 PyObject * obj1 = 0 ;
28166 char *kwnames[] = {
28167 (char *) "self",(char *) "pt", NULL
28168 };
28169
28170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28172 if (SWIG_arg_fail(1)) SWIG_fail;
28173 {
28174 arg2 = &temp2;
28175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 {
28185 wxPoint * resultptr;
28186 resultptr = new wxPoint((wxPoint &)(result));
28187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28188 }
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj;
28197 wxWindow *arg1 = (wxWindow *) 0 ;
28198 wxSize *arg2 = 0 ;
28199 wxSize result;
28200 wxSize temp2 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 char *kwnames[] = {
28204 (char *) "self",(char *) "sz", NULL
28205 };
28206
28207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
28212 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28213 }
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 wxSize * resultptr;
28223 resultptr = new wxSize((wxSize &)(result));
28224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28225 }
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj;
28234 wxWindow *arg1 = (wxWindow *) 0 ;
28235 int arg2 ;
28236 int arg3 ;
28237 PyObject * obj0 = 0 ;
28238 PyObject * obj1 = 0 ;
28239 PyObject * obj2 = 0 ;
28240 char *kwnames[] = {
28241 (char *) "self",(char *) "x",(char *) "y", NULL
28242 };
28243
28244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28246 if (SWIG_arg_fail(1)) SWIG_fail;
28247 {
28248 arg2 = (int)(SWIG_As_int(obj1));
28249 if (SWIG_arg_fail(2)) SWIG_fail;
28250 }
28251 {
28252 arg3 = (int)(SWIG_As_int(obj2));
28253 if (SWIG_arg_fail(3)) SWIG_fail;
28254 }
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 (arg1)->WarpPointer(arg2,arg3);
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 Py_INCREF(Py_None); resultobj = Py_None;
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj;
28271 wxWindow *arg1 = (wxWindow *) 0 ;
28272 PyObject * obj0 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28279 if (SWIG_arg_fail(1)) SWIG_fail;
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 (arg1)->CaptureMouse();
28283
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 Py_INCREF(Py_None); resultobj = Py_None;
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj;
28296 wxWindow *arg1 = (wxWindow *) 0 ;
28297 PyObject * obj0 = 0 ;
28298 char *kwnames[] = {
28299 (char *) "self", NULL
28300 };
28301
28302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28304 if (SWIG_arg_fail(1)) SWIG_fail;
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 (arg1)->ReleaseMouse();
28308
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 Py_INCREF(Py_None); resultobj = Py_None;
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxWindow *result;
28322 char *kwnames[] = {
28323 NULL
28324 };
28325
28326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28327 {
28328 if (!wxPyCheckForApp()) SWIG_fail;
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (wxWindow *)wxWindow::GetCapture();
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = wxPyMake_wxObject(result, 0);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj;
28346 wxWindow *arg1 = (wxWindow *) 0 ;
28347 bool result;
28348 PyObject * obj0 = 0 ;
28349 char *kwnames[] = {
28350 (char *) "self", NULL
28351 };
28352
28353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28355 if (SWIG_arg_fail(1)) SWIG_fail;
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 result = (bool)((wxWindow const *)arg1)->HasCapture();
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 {
28364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28365 }
28366 return resultobj;
28367 fail:
28368 return NULL;
28369 }
28370
28371
28372 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28373 PyObject *resultobj;
28374 wxWindow *arg1 = (wxWindow *) 0 ;
28375 bool arg2 = (bool) true ;
28376 wxRect *arg3 = (wxRect *) NULL ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 PyObject * obj2 = 0 ;
28380 char *kwnames[] = {
28381 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28382 };
28383
28384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28386 if (SWIG_arg_fail(1)) SWIG_fail;
28387 if (obj1) {
28388 {
28389 arg2 = (bool)(SWIG_As_bool(obj1));
28390 if (SWIG_arg_fail(2)) SWIG_fail;
28391 }
28392 }
28393 if (obj2) {
28394 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(3)) SWIG_fail;
28396 }
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28400
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 Py_INCREF(Py_None); resultobj = Py_None;
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28412 PyObject *resultobj;
28413 wxWindow *arg1 = (wxWindow *) 0 ;
28414 wxRect *arg2 = 0 ;
28415 bool arg3 = (bool) true ;
28416 wxRect temp2 ;
28417 PyObject * obj0 = 0 ;
28418 PyObject * obj1 = 0 ;
28419 PyObject * obj2 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 {
28428 arg2 = &temp2;
28429 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28430 }
28431 if (obj2) {
28432 {
28433 arg3 = (bool)(SWIG_As_bool(obj2));
28434 if (SWIG_arg_fail(3)) SWIG_fail;
28435 }
28436 }
28437 {
28438 PyThreadState* __tstate = wxPyBeginAllowThreads();
28439 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
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_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj;
28453 wxWindow *arg1 = (wxWindow *) 0 ;
28454 PyObject * obj0 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "self", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28461 if (SWIG_arg_fail(1)) SWIG_fail;
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 (arg1)->Update();
28465
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 Py_INCREF(Py_None); resultobj = Py_None;
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj;
28478 wxWindow *arg1 = (wxWindow *) 0 ;
28479 PyObject * obj0 = 0 ;
28480 char *kwnames[] = {
28481 (char *) "self", NULL
28482 };
28483
28484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28486 if (SWIG_arg_fail(1)) SWIG_fail;
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 (arg1)->ClearBackground();
28490
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 Py_INCREF(Py_None); resultobj = Py_None;
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxWindow *arg1 = (wxWindow *) 0 ;
28504 PyObject * obj0 = 0 ;
28505 char *kwnames[] = {
28506 (char *) "self", NULL
28507 };
28508
28509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28511 if (SWIG_arg_fail(1)) SWIG_fail;
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 (arg1)->Freeze();
28515
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 Py_INCREF(Py_None); resultobj = Py_None;
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28527 PyObject *resultobj;
28528 wxWindow *arg1 = (wxWindow *) 0 ;
28529 PyObject * obj0 = 0 ;
28530 char *kwnames[] = {
28531 (char *) "self", NULL
28532 };
28533
28534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28536 if (SWIG_arg_fail(1)) SWIG_fail;
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 (arg1)->Thaw();
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 Py_INCREF(Py_None); resultobj = Py_None;
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj;
28553 wxWindow *arg1 = (wxWindow *) 0 ;
28554 wxDC *arg2 = 0 ;
28555 PyObject * obj0 = 0 ;
28556 PyObject * obj1 = 0 ;
28557 char *kwnames[] = {
28558 (char *) "self",(char *) "dc", NULL
28559 };
28560
28561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28563 if (SWIG_arg_fail(1)) SWIG_fail;
28564 {
28565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28566 if (SWIG_arg_fail(2)) SWIG_fail;
28567 if (arg2 == NULL) {
28568 SWIG_null_ref("wxDC");
28569 }
28570 if (SWIG_arg_fail(2)) SWIG_fail;
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->PrepareDC(*arg2);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 Py_INCREF(Py_None); resultobj = Py_None;
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxWindow *arg1 = (wxWindow *) 0 ;
28589 wxRegion *result;
28590 PyObject * obj0 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "self", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 {
28601 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28602 result = (wxRegion *) &_result_ref;
28603 }
28604
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj;
28617 wxWindow *arg1 = (wxWindow *) 0 ;
28618 wxRect result;
28619 PyObject * obj0 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 {
28635 wxRect * resultptr;
28636 resultptr = new wxRect((wxRect &)(result));
28637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28646 PyObject *resultobj;
28647 wxWindow *arg1 = (wxWindow *) 0 ;
28648 int arg2 ;
28649 int arg3 ;
28650 int arg4 = (int) 1 ;
28651 int arg5 = (int) 1 ;
28652 bool result;
28653 PyObject * obj0 = 0 ;
28654 PyObject * obj1 = 0 ;
28655 PyObject * obj2 = 0 ;
28656 PyObject * obj3 = 0 ;
28657 PyObject * obj4 = 0 ;
28658 char *kwnames[] = {
28659 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28660 };
28661
28662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28664 if (SWIG_arg_fail(1)) SWIG_fail;
28665 {
28666 arg2 = (int)(SWIG_As_int(obj1));
28667 if (SWIG_arg_fail(2)) SWIG_fail;
28668 }
28669 {
28670 arg3 = (int)(SWIG_As_int(obj2));
28671 if (SWIG_arg_fail(3)) SWIG_fail;
28672 }
28673 if (obj3) {
28674 {
28675 arg4 = (int)(SWIG_As_int(obj3));
28676 if (SWIG_arg_fail(4)) SWIG_fail;
28677 }
28678 }
28679 if (obj4) {
28680 {
28681 arg5 = (int)(SWIG_As_int(obj4));
28682 if (SWIG_arg_fail(5)) SWIG_fail;
28683 }
28684 }
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 {
28693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28694 }
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj;
28703 wxWindow *arg1 = (wxWindow *) 0 ;
28704 wxPoint *arg2 = 0 ;
28705 bool result;
28706 wxPoint temp2 ;
28707 PyObject * obj0 = 0 ;
28708 PyObject * obj1 = 0 ;
28709 char *kwnames[] = {
28710 (char *) "self",(char *) "pt", NULL
28711 };
28712
28713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28715 if (SWIG_arg_fail(1)) SWIG_fail;
28716 {
28717 arg2 = &temp2;
28718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28719 }
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 {
28728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28729 }
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj;
28738 wxWindow *arg1 = (wxWindow *) 0 ;
28739 wxRect *arg2 = 0 ;
28740 bool result;
28741 wxRect temp2 ;
28742 PyObject * obj0 = 0 ;
28743 PyObject * obj1 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "rect", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 arg2 = &temp2;
28753 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28754 }
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28758
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 {
28763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28764 }
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj;
28773 wxWindow *arg1 = (wxWindow *) 0 ;
28774 wxVisualAttributes result;
28775 PyObject * obj0 = 0 ;
28776 char *kwnames[] = {
28777 (char *) "self", NULL
28778 };
28779
28780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28782 if (SWIG_arg_fail(1)) SWIG_fail;
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28786
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 {
28791 wxVisualAttributes * resultptr;
28792 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28794 }
28795 return resultobj;
28796 fail:
28797 return NULL;
28798 }
28799
28800
28801 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28802 PyObject *resultobj;
28803 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28804 wxVisualAttributes result;
28805 PyObject * obj0 = 0 ;
28806 char *kwnames[] = {
28807 (char *) "variant", NULL
28808 };
28809
28810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28811 if (obj0) {
28812 {
28813 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 }
28816 }
28817 {
28818 if (!wxPyCheckForApp()) SWIG_fail;
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28821
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 {
28826 wxVisualAttributes * resultptr;
28827 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28829 }
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj;
28838 wxWindow *arg1 = (wxWindow *) 0 ;
28839 wxColour *arg2 = 0 ;
28840 bool result;
28841 wxColour temp2 ;
28842 PyObject * obj0 = 0 ;
28843 PyObject * obj1 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self",(char *) "colour", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 {
28852 arg2 = &temp2;
28853 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28854 }
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 {
28863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28864 }
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj;
28873 wxWindow *arg1 = (wxWindow *) 0 ;
28874 wxColour *arg2 = 0 ;
28875 wxColour temp2 ;
28876 PyObject * obj0 = 0 ;
28877 PyObject * obj1 = 0 ;
28878 char *kwnames[] = {
28879 (char *) "self",(char *) "colour", NULL
28880 };
28881
28882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28884 if (SWIG_arg_fail(1)) SWIG_fail;
28885 {
28886 arg2 = &temp2;
28887 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28888 }
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28892
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 Py_INCREF(Py_None); resultobj = Py_None;
28897 return resultobj;
28898 fail:
28899 return NULL;
28900 }
28901
28902
28903 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28904 PyObject *resultobj;
28905 wxWindow *arg1 = (wxWindow *) 0 ;
28906 wxColour *arg2 = 0 ;
28907 bool result;
28908 wxColour temp2 ;
28909 PyObject * obj0 = 0 ;
28910 PyObject * obj1 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self",(char *) "colour", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 arg2 = &temp2;
28920 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28921 }
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
28925
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 {
28930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28931 }
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj;
28940 wxWindow *arg1 = (wxWindow *) 0 ;
28941 wxColour *arg2 = 0 ;
28942 wxColour temp2 ;
28943 PyObject * obj0 = 0 ;
28944 PyObject * obj1 = 0 ;
28945 char *kwnames[] = {
28946 (char *) "self",(char *) "colour", NULL
28947 };
28948
28949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
28950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(1)) SWIG_fail;
28952 {
28953 arg2 = &temp2;
28954 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28955 }
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
28959
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 Py_INCREF(Py_None); resultobj = Py_None;
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28971 PyObject *resultobj;
28972 wxWindow *arg1 = (wxWindow *) 0 ;
28973 wxColour result;
28974 PyObject * obj0 = 0 ;
28975 char *kwnames[] = {
28976 (char *) "self", NULL
28977 };
28978
28979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
28980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28981 if (SWIG_arg_fail(1)) SWIG_fail;
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = ((wxWindow const *)arg1)->GetBackgroundColour();
28985
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 {
28990 wxColour * resultptr;
28991 resultptr = new wxColour((wxColour &)(result));
28992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28993 }
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxWindow *arg1 = (wxWindow *) 0 ;
29003 wxColour result;
29004 PyObject * obj0 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29011 if (SWIG_arg_fail(1)) SWIG_fail;
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = ((wxWindow const *)arg1)->GetForegroundColour();
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 {
29020 wxColour * resultptr;
29021 resultptr = new wxColour((wxColour &)(result));
29022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29023 }
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj;
29032 wxWindow *arg1 = (wxWindow *) 0 ;
29033 wxBackgroundStyle arg2 ;
29034 bool result;
29035 PyObject * obj0 = 0 ;
29036 PyObject * obj1 = 0 ;
29037 char *kwnames[] = {
29038 (char *) "self",(char *) "style", NULL
29039 };
29040
29041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29043 if (SWIG_arg_fail(1)) SWIG_fail;
29044 {
29045 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29046 if (SWIG_arg_fail(2)) SWIG_fail;
29047 }
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 {
29056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29057 }
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj;
29066 wxWindow *arg1 = (wxWindow *) 0 ;
29067 wxBackgroundStyle result;
29068 PyObject * obj0 = 0 ;
29069 char *kwnames[] = {
29070 (char *) "self", NULL
29071 };
29072
29073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29075 if (SWIG_arg_fail(1)) SWIG_fail;
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 resultobj = SWIG_From_int((result));
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxWindow *arg1 = (wxWindow *) 0 ;
29093 bool result;
29094 PyObject * obj0 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = (bool)(arg1)->HasTransparentBackground();
29105
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 {
29110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29111 }
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 wxCursor *arg2 = 0 ;
29122 bool result;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 char *kwnames[] = {
29126 (char *) "self",(char *) "cursor", NULL
29127 };
29128
29129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29131 if (SWIG_arg_fail(1)) SWIG_fail;
29132 {
29133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29134 if (SWIG_arg_fail(2)) SWIG_fail;
29135 if (arg2 == NULL) {
29136 SWIG_null_ref("wxCursor");
29137 }
29138 if (SWIG_arg_fail(2)) SWIG_fail;
29139 }
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29143
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 {
29148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29149 }
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj;
29158 wxWindow *arg1 = (wxWindow *) 0 ;
29159 wxCursor result;
29160 PyObject * obj0 = 0 ;
29161 char *kwnames[] = {
29162 (char *) "self", NULL
29163 };
29164
29165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29167 if (SWIG_arg_fail(1)) SWIG_fail;
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 result = (arg1)->GetCursor();
29171
29172 wxPyEndAllowThreads(__tstate);
29173 if (PyErr_Occurred()) SWIG_fail;
29174 }
29175 {
29176 wxCursor * resultptr;
29177 resultptr = new wxCursor((wxCursor &)(result));
29178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29179 }
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29187 PyObject *resultobj;
29188 wxWindow *arg1 = (wxWindow *) 0 ;
29189 wxFont *arg2 = 0 ;
29190 bool result;
29191 PyObject * obj0 = 0 ;
29192 PyObject * obj1 = 0 ;
29193 char *kwnames[] = {
29194 (char *) "self",(char *) "font", NULL
29195 };
29196
29197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29199 if (SWIG_arg_fail(1)) SWIG_fail;
29200 {
29201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29202 if (SWIG_arg_fail(2)) SWIG_fail;
29203 if (arg2 == NULL) {
29204 SWIG_null_ref("wxFont");
29205 }
29206 if (SWIG_arg_fail(2)) SWIG_fail;
29207 }
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29211
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 {
29216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29217 }
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj;
29226 wxWindow *arg1 = (wxWindow *) 0 ;
29227 wxFont *arg2 = 0 ;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 char *kwnames[] = {
29231 (char *) "self",(char *) "font", NULL
29232 };
29233
29234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29236 if (SWIG_arg_fail(1)) SWIG_fail;
29237 {
29238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(2)) SWIG_fail;
29240 if (arg2 == NULL) {
29241 SWIG_null_ref("wxFont");
29242 }
29243 if (SWIG_arg_fail(2)) SWIG_fail;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 (arg1)->SetOwnFont((wxFont const &)*arg2);
29248
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 Py_INCREF(Py_None); resultobj = Py_None;
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj;
29261 wxWindow *arg1 = (wxWindow *) 0 ;
29262 wxFont result;
29263 PyObject * obj0 = 0 ;
29264 char *kwnames[] = {
29265 (char *) "self", NULL
29266 };
29267
29268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(1)) SWIG_fail;
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 result = (arg1)->GetFont();
29274
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 {
29279 wxFont * resultptr;
29280 resultptr = new wxFont((wxFont &)(result));
29281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29282 }
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj;
29291 wxWindow *arg1 = (wxWindow *) 0 ;
29292 wxCaret *arg2 = (wxCaret *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 PyObject * obj1 = 0 ;
29295 char *kwnames[] = {
29296 (char *) "self",(char *) "caret", NULL
29297 };
29298
29299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29301 if (SWIG_arg_fail(1)) SWIG_fail;
29302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29303 if (SWIG_arg_fail(2)) SWIG_fail;
29304 {
29305 PyThreadState* __tstate = wxPyBeginAllowThreads();
29306 (arg1)->SetCaret(arg2);
29307
29308 wxPyEndAllowThreads(__tstate);
29309 if (PyErr_Occurred()) SWIG_fail;
29310 }
29311 Py_INCREF(Py_None); resultobj = Py_None;
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29319 PyObject *resultobj;
29320 wxWindow *arg1 = (wxWindow *) 0 ;
29321 wxCaret *result;
29322 PyObject * obj0 = 0 ;
29323 char *kwnames[] = {
29324 (char *) "self", NULL
29325 };
29326
29327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29329 if (SWIG_arg_fail(1)) SWIG_fail;
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29333
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 int result;
29348 PyObject * obj0 = 0 ;
29349 char *kwnames[] = {
29350 (char *) "self", NULL
29351 };
29352
29353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29359
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 {
29364 resultobj = SWIG_From_int((int)(result));
29365 }
29366 return resultobj;
29367 fail:
29368 return NULL;
29369 }
29370
29371
29372 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29373 PyObject *resultobj;
29374 wxWindow *arg1 = (wxWindow *) 0 ;
29375 int result;
29376 PyObject * obj0 = 0 ;
29377 char *kwnames[] = {
29378 (char *) "self", NULL
29379 };
29380
29381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29383 if (SWIG_arg_fail(1)) SWIG_fail;
29384 {
29385 PyThreadState* __tstate = wxPyBeginAllowThreads();
29386 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29387
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 {
29392 resultobj = SWIG_From_int((int)(result));
29393 }
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29401 PyObject *resultobj;
29402 wxWindow *arg1 = (wxWindow *) 0 ;
29403 wxString *arg2 = 0 ;
29404 int *arg3 = (int *) 0 ;
29405 int *arg4 = (int *) 0 ;
29406 bool temp2 = false ;
29407 int temp3 ;
29408 int res3 = 0 ;
29409 int temp4 ;
29410 int res4 = 0 ;
29411 PyObject * obj0 = 0 ;
29412 PyObject * obj1 = 0 ;
29413 char *kwnames[] = {
29414 (char *) "self",(char *) "string", NULL
29415 };
29416
29417 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29418 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(1)) SWIG_fail;
29422 {
29423 arg2 = wxString_in_helper(obj1);
29424 if (arg2 == NULL) SWIG_fail;
29425 temp2 = true;
29426 }
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29430
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 Py_INCREF(Py_None); resultobj = Py_None;
29435 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29436 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29437 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29438 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29439 {
29440 if (temp2)
29441 delete arg2;
29442 }
29443 return resultobj;
29444 fail:
29445 {
29446 if (temp2)
29447 delete arg2;
29448 }
29449 return NULL;
29450 }
29451
29452
29453 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj;
29455 wxWindow *arg1 = (wxWindow *) 0 ;
29456 wxString *arg2 = 0 ;
29457 int *arg3 = (int *) 0 ;
29458 int *arg4 = (int *) 0 ;
29459 int *arg5 = (int *) 0 ;
29460 int *arg6 = (int *) 0 ;
29461 wxFont *arg7 = (wxFont *) NULL ;
29462 bool temp2 = false ;
29463 int temp3 ;
29464 int res3 = 0 ;
29465 int temp4 ;
29466 int res4 = 0 ;
29467 int temp5 ;
29468 int res5 = 0 ;
29469 int temp6 ;
29470 int res6 = 0 ;
29471 PyObject * obj0 = 0 ;
29472 PyObject * obj1 = 0 ;
29473 PyObject * obj2 = 0 ;
29474 char *kwnames[] = {
29475 (char *) "self",(char *) "string",(char *) "font", NULL
29476 };
29477
29478 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29479 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29480 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29481 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(1)) SWIG_fail;
29485 {
29486 arg2 = wxString_in_helper(obj1);
29487 if (arg2 == NULL) SWIG_fail;
29488 temp2 = true;
29489 }
29490 if (obj2) {
29491 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29492 if (SWIG_arg_fail(7)) SWIG_fail;
29493 }
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29497
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 Py_INCREF(Py_None); resultobj = Py_None;
29502 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29503 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29504 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29505 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29506 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29507 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29508 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29509 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29510 {
29511 if (temp2)
29512 delete arg2;
29513 }
29514 return resultobj;
29515 fail:
29516 {
29517 if (temp2)
29518 delete arg2;
29519 }
29520 return NULL;
29521 }
29522
29523
29524 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj;
29526 wxWindow *arg1 = (wxWindow *) 0 ;
29527 int *arg2 = (int *) 0 ;
29528 int *arg3 = (int *) 0 ;
29529 int temp2 ;
29530 int res2 = 0 ;
29531 int temp3 ;
29532 int res3 = 0 ;
29533 PyObject * obj0 = 0 ;
29534 PyObject * obj1 = 0 ;
29535 PyObject * obj2 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "x",(char *) "y", NULL
29538 };
29539
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(1)) SWIG_fail;
29543 {
29544 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29545 temp2 = SWIG_As_int(obj1);
29546 if (SWIG_arg_fail(2)) SWIG_fail;
29547 arg2 = &temp2;
29548 res2 = SWIG_NEWOBJ;
29549 }
29550 }
29551 {
29552 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29553 temp3 = SWIG_As_int(obj2);
29554 if (SWIG_arg_fail(3)) SWIG_fail;
29555 arg3 = &temp3;
29556 res3 = SWIG_NEWOBJ;
29557 }
29558 }
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 Py_INCREF(Py_None); resultobj = Py_None;
29567 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29568 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29569 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29570 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29578 PyObject *resultobj;
29579 wxWindow *arg1 = (wxWindow *) 0 ;
29580 int *arg2 = (int *) 0 ;
29581 int *arg3 = (int *) 0 ;
29582 int temp2 ;
29583 int res2 = 0 ;
29584 int temp3 ;
29585 int res3 = 0 ;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 PyObject * obj2 = 0 ;
29589 char *kwnames[] = {
29590 (char *) "self",(char *) "x",(char *) "y", NULL
29591 };
29592
29593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29595 if (SWIG_arg_fail(1)) SWIG_fail;
29596 {
29597 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29598 temp2 = SWIG_As_int(obj1);
29599 if (SWIG_arg_fail(2)) SWIG_fail;
29600 arg2 = &temp2;
29601 res2 = SWIG_NEWOBJ;
29602 }
29603 }
29604 {
29605 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29606 temp3 = SWIG_As_int(obj2);
29607 if (SWIG_arg_fail(3)) SWIG_fail;
29608 arg3 = &temp3;
29609 res3 = SWIG_NEWOBJ;
29610 }
29611 }
29612 {
29613 PyThreadState* __tstate = wxPyBeginAllowThreads();
29614 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29615
29616 wxPyEndAllowThreads(__tstate);
29617 if (PyErr_Occurred()) SWIG_fail;
29618 }
29619 Py_INCREF(Py_None); resultobj = Py_None;
29620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj;
29632 wxWindow *arg1 = (wxWindow *) 0 ;
29633 wxPoint *arg2 = 0 ;
29634 wxPoint result;
29635 wxPoint temp2 ;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self",(char *) "pt", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(1)) SWIG_fail;
29645 {
29646 arg2 = &temp2;
29647 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29648 }
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 wxPoint * resultptr;
29658 resultptr = new wxPoint((wxPoint &)(result));
29659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29660 }
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxWindow *arg1 = (wxWindow *) 0 ;
29670 wxPoint *arg2 = 0 ;
29671 wxPoint result;
29672 wxPoint temp2 ;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 char *kwnames[] = {
29676 (char *) "self",(char *) "pt", NULL
29677 };
29678
29679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29681 if (SWIG_arg_fail(1)) SWIG_fail;
29682 {
29683 arg2 = &temp2;
29684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29685 }
29686 {
29687 PyThreadState* __tstate = wxPyBeginAllowThreads();
29688 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29689
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 {
29694 wxPoint * resultptr;
29695 resultptr = new wxPoint((wxPoint &)(result));
29696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29697 }
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj;
29706 wxWindow *arg1 = (wxWindow *) 0 ;
29707 int arg2 ;
29708 int arg3 ;
29709 wxHitTest result;
29710 PyObject * obj0 = 0 ;
29711 PyObject * obj1 = 0 ;
29712 PyObject * obj2 = 0 ;
29713 char *kwnames[] = {
29714 (char *) "self",(char *) "x",(char *) "y", NULL
29715 };
29716
29717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29719 if (SWIG_arg_fail(1)) SWIG_fail;
29720 {
29721 arg2 = (int)(SWIG_As_int(obj1));
29722 if (SWIG_arg_fail(2)) SWIG_fail;
29723 }
29724 {
29725 arg3 = (int)(SWIG_As_int(obj2));
29726 if (SWIG_arg_fail(3)) SWIG_fail;
29727 }
29728 {
29729 PyThreadState* __tstate = wxPyBeginAllowThreads();
29730 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29731
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 resultobj = SWIG_From_int((result));
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj;
29744 wxWindow *arg1 = (wxWindow *) 0 ;
29745 wxPoint *arg2 = 0 ;
29746 wxHitTest result;
29747 wxPoint temp2 ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 char *kwnames[] = {
29751 (char *) "self",(char *) "pt", NULL
29752 };
29753
29754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29756 if (SWIG_arg_fail(1)) SWIG_fail;
29757 {
29758 arg2 = &temp2;
29759 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29764
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 resultobj = SWIG_From_int((result));
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29776 PyObject *resultobj;
29777 wxWindow *arg1 = (wxWindow *) 0 ;
29778 long arg2 ;
29779 wxBorder result;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782
29783 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29785 if (SWIG_arg_fail(1)) SWIG_fail;
29786 {
29787 arg2 = (long)(SWIG_As_long(obj1));
29788 if (SWIG_arg_fail(2)) SWIG_fail;
29789 }
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29793
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_From_int((result));
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29805 PyObject *resultobj;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 wxBorder result;
29808 PyObject * obj0 = 0 ;
29809
29810 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29812 if (SWIG_arg_fail(1)) SWIG_fail;
29813 {
29814 PyThreadState* __tstate = wxPyBeginAllowThreads();
29815 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29816
29817 wxPyEndAllowThreads(__tstate);
29818 if (PyErr_Occurred()) SWIG_fail;
29819 }
29820 resultobj = SWIG_From_int((result));
29821 return resultobj;
29822 fail:
29823 return NULL;
29824 }
29825
29826
29827 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29828 int argc;
29829 PyObject *argv[3];
29830 int ii;
29831
29832 argc = PyObject_Length(args);
29833 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29834 argv[ii] = PyTuple_GetItem(args,ii);
29835 }
29836 if (argc == 1) {
29837 int _v;
29838 {
29839 void *ptr;
29840 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29841 _v = 0;
29842 PyErr_Clear();
29843 } else {
29844 _v = 1;
29845 }
29846 }
29847 if (_v) {
29848 return _wrap_Window_GetBorder__SWIG_1(self,args);
29849 }
29850 }
29851 if (argc == 2) {
29852 int _v;
29853 {
29854 void *ptr;
29855 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29856 _v = 0;
29857 PyErr_Clear();
29858 } else {
29859 _v = 1;
29860 }
29861 }
29862 if (_v) {
29863 _v = SWIG_Check_long(argv[1]);
29864 if (_v) {
29865 return _wrap_Window_GetBorder__SWIG_0(self,args);
29866 }
29867 }
29868 }
29869
29870 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 long arg2 = (long) wxUPDATE_UI_NONE ;
29879 PyObject * obj0 = 0 ;
29880 PyObject * obj1 = 0 ;
29881 char *kwnames[] = {
29882 (char *) "self",(char *) "flags", NULL
29883 };
29884
29885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29887 if (SWIG_arg_fail(1)) SWIG_fail;
29888 if (obj1) {
29889 {
29890 arg2 = (long)(SWIG_As_long(obj1));
29891 if (SWIG_arg_fail(2)) SWIG_fail;
29892 }
29893 }
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->UpdateWindowUI(arg2);
29897
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 Py_INCREF(Py_None); resultobj = Py_None;
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj;
29910 wxWindow *arg1 = (wxWindow *) 0 ;
29911 wxMenu *arg2 = (wxMenu *) 0 ;
29912 int arg3 = (int) -1 ;
29913 int arg4 = (int) -1 ;
29914 bool result;
29915 PyObject * obj0 = 0 ;
29916 PyObject * obj1 = 0 ;
29917 PyObject * obj2 = 0 ;
29918 PyObject * obj3 = 0 ;
29919 char *kwnames[] = {
29920 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29921 };
29922
29923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29925 if (SWIG_arg_fail(1)) SWIG_fail;
29926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29927 if (SWIG_arg_fail(2)) SWIG_fail;
29928 if (obj2) {
29929 {
29930 arg3 = (int)(SWIG_As_int(obj2));
29931 if (SWIG_arg_fail(3)) SWIG_fail;
29932 }
29933 }
29934 if (obj3) {
29935 {
29936 arg4 = (int)(SWIG_As_int(obj3));
29937 if (SWIG_arg_fail(4)) SWIG_fail;
29938 }
29939 }
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 {
29948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29949 }
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
29957 PyObject *resultobj;
29958 wxWindow *arg1 = (wxWindow *) 0 ;
29959 wxMenu *arg2 = (wxMenu *) 0 ;
29960 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29961 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29962 bool result;
29963 wxPoint temp3 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 PyObject * obj2 = 0 ;
29967 char *kwnames[] = {
29968 (char *) "self",(char *) "menu",(char *) "pos", NULL
29969 };
29970
29971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
29972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29973 if (SWIG_arg_fail(1)) SWIG_fail;
29974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(2)) SWIG_fail;
29976 if (obj2) {
29977 {
29978 arg3 = &temp3;
29979 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29980 }
29981 }
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
29985
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 {
29990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29991 }
29992 return resultobj;
29993 fail:
29994 return NULL;
29995 }
29996
29997
29998 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
29999 PyObject *resultobj;
30000 wxWindow *arg1 = (wxWindow *) 0 ;
30001 long result;
30002 PyObject * obj0 = 0 ;
30003 char *kwnames[] = {
30004 (char *) "self", NULL
30005 };
30006
30007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30009 if (SWIG_arg_fail(1)) SWIG_fail;
30010 {
30011 PyThreadState* __tstate = wxPyBeginAllowThreads();
30012 result = (long)wxWindow_GetHandle(arg1);
30013
30014 wxPyEndAllowThreads(__tstate);
30015 if (PyErr_Occurred()) SWIG_fail;
30016 }
30017 {
30018 resultobj = SWIG_From_long((long)(result));
30019 }
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30027 PyObject *resultobj;
30028 wxWindow *arg1 = (wxWindow *) 0 ;
30029 long arg2 ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char *kwnames[] = {
30033 (char *) "self",(char *) "handle", NULL
30034 };
30035
30036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",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 arg2 = (long)(SWIG_As_long(obj1));
30041 if (SWIG_arg_fail(2)) SWIG_fail;
30042 }
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 wxWindow_AssociateHandle(arg1,arg2);
30046
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 Py_INCREF(Py_None); resultobj = Py_None;
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30058 PyObject *resultobj;
30059 wxWindow *arg1 = (wxWindow *) 0 ;
30060 PyObject * obj0 = 0 ;
30061 char *kwnames[] = {
30062 (char *) "self", NULL
30063 };
30064
30065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30067 if (SWIG_arg_fail(1)) SWIG_fail;
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 (arg1)->DissociateHandle();
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 Py_INCREF(Py_None); resultobj = Py_None;
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj;
30084 wxWindow *arg1 = (wxWindow *) 0 ;
30085 int arg2 ;
30086 bool result;
30087 PyObject * obj0 = 0 ;
30088 PyObject * obj1 = 0 ;
30089 char *kwnames[] = {
30090 (char *) "self",(char *) "orient", NULL
30091 };
30092
30093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30095 if (SWIG_arg_fail(1)) SWIG_fail;
30096 {
30097 arg2 = (int)(SWIG_As_int(obj1));
30098 if (SWIG_arg_fail(2)) SWIG_fail;
30099 }
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30103
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj;
30118 wxWindow *arg1 = (wxWindow *) 0 ;
30119 int arg2 ;
30120 int arg3 ;
30121 int arg4 ;
30122 int arg5 ;
30123 bool arg6 = (bool) true ;
30124 PyObject * obj0 = 0 ;
30125 PyObject * obj1 = 0 ;
30126 PyObject * obj2 = 0 ;
30127 PyObject * obj3 = 0 ;
30128 PyObject * obj4 = 0 ;
30129 PyObject * obj5 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 {
30138 arg2 = (int)(SWIG_As_int(obj1));
30139 if (SWIG_arg_fail(2)) SWIG_fail;
30140 }
30141 {
30142 arg3 = (int)(SWIG_As_int(obj2));
30143 if (SWIG_arg_fail(3)) SWIG_fail;
30144 }
30145 {
30146 arg4 = (int)(SWIG_As_int(obj3));
30147 if (SWIG_arg_fail(4)) SWIG_fail;
30148 }
30149 {
30150 arg5 = (int)(SWIG_As_int(obj4));
30151 if (SWIG_arg_fail(5)) SWIG_fail;
30152 }
30153 if (obj5) {
30154 {
30155 arg6 = (bool)(SWIG_As_bool(obj5));
30156 if (SWIG_arg_fail(6)) SWIG_fail;
30157 }
30158 }
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30162
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 Py_INCREF(Py_None); resultobj = Py_None;
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj;
30175 wxWindow *arg1 = (wxWindow *) 0 ;
30176 int arg2 ;
30177 int arg3 ;
30178 bool arg4 = (bool) true ;
30179 PyObject * obj0 = 0 ;
30180 PyObject * obj1 = 0 ;
30181 PyObject * obj2 = 0 ;
30182 PyObject * obj3 = 0 ;
30183 char *kwnames[] = {
30184 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30185 };
30186
30187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30189 if (SWIG_arg_fail(1)) SWIG_fail;
30190 {
30191 arg2 = (int)(SWIG_As_int(obj1));
30192 if (SWIG_arg_fail(2)) SWIG_fail;
30193 }
30194 {
30195 arg3 = (int)(SWIG_As_int(obj2));
30196 if (SWIG_arg_fail(3)) SWIG_fail;
30197 }
30198 if (obj3) {
30199 {
30200 arg4 = (bool)(SWIG_As_bool(obj3));
30201 if (SWIG_arg_fail(4)) SWIG_fail;
30202 }
30203 }
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->SetScrollPos(arg2,arg3,arg4);
30207
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 Py_INCREF(Py_None); resultobj = Py_None;
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj;
30220 wxWindow *arg1 = (wxWindow *) 0 ;
30221 int arg2 ;
30222 int result;
30223 PyObject * obj0 = 0 ;
30224 PyObject * obj1 = 0 ;
30225 char *kwnames[] = {
30226 (char *) "self",(char *) "orientation", NULL
30227 };
30228
30229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30231 if (SWIG_arg_fail(1)) SWIG_fail;
30232 {
30233 arg2 = (int)(SWIG_As_int(obj1));
30234 if (SWIG_arg_fail(2)) SWIG_fail;
30235 }
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30239
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 {
30244 resultobj = SWIG_From_int((int)(result));
30245 }
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj;
30254 wxWindow *arg1 = (wxWindow *) 0 ;
30255 int arg2 ;
30256 int result;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "self",(char *) "orientation", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 {
30267 arg2 = (int)(SWIG_As_int(obj1));
30268 if (SWIG_arg_fail(2)) SWIG_fail;
30269 }
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30273
30274 wxPyEndAllowThreads(__tstate);
30275 if (PyErr_Occurred()) SWIG_fail;
30276 }
30277 {
30278 resultobj = SWIG_From_int((int)(result));
30279 }
30280 return resultobj;
30281 fail:
30282 return NULL;
30283 }
30284
30285
30286 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30287 PyObject *resultobj;
30288 wxWindow *arg1 = (wxWindow *) 0 ;
30289 int arg2 ;
30290 int result;
30291 PyObject * obj0 = 0 ;
30292 PyObject * obj1 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self",(char *) "orientation", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 arg2 = (int)(SWIG_As_int(obj1));
30302 if (SWIG_arg_fail(2)) SWIG_fail;
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 {
30312 resultobj = SWIG_From_int((int)(result));
30313 }
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj;
30322 wxWindow *arg1 = (wxWindow *) 0 ;
30323 int arg2 ;
30324 int arg3 ;
30325 wxRect *arg4 = (wxRect *) NULL ;
30326 PyObject * obj0 = 0 ;
30327 PyObject * obj1 = 0 ;
30328 PyObject * obj2 = 0 ;
30329 PyObject * obj3 = 0 ;
30330 char *kwnames[] = {
30331 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30332 };
30333
30334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30336 if (SWIG_arg_fail(1)) SWIG_fail;
30337 {
30338 arg2 = (int)(SWIG_As_int(obj1));
30339 if (SWIG_arg_fail(2)) SWIG_fail;
30340 }
30341 {
30342 arg3 = (int)(SWIG_As_int(obj2));
30343 if (SWIG_arg_fail(3)) SWIG_fail;
30344 }
30345 if (obj3) {
30346 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(4)) SWIG_fail;
30348 }
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30352
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 Py_INCREF(Py_None); resultobj = Py_None;
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30364 PyObject *resultobj;
30365 wxWindow *arg1 = (wxWindow *) 0 ;
30366 int arg2 ;
30367 bool result;
30368 PyObject * obj0 = 0 ;
30369 PyObject * obj1 = 0 ;
30370 char *kwnames[] = {
30371 (char *) "self",(char *) "lines", NULL
30372 };
30373
30374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30376 if (SWIG_arg_fail(1)) SWIG_fail;
30377 {
30378 arg2 = (int)(SWIG_As_int(obj1));
30379 if (SWIG_arg_fail(2)) SWIG_fail;
30380 }
30381 {
30382 PyThreadState* __tstate = wxPyBeginAllowThreads();
30383 result = (bool)(arg1)->ScrollLines(arg2);
30384
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 {
30389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30390 }
30391 return resultobj;
30392 fail:
30393 return NULL;
30394 }
30395
30396
30397 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30398 PyObject *resultobj;
30399 wxWindow *arg1 = (wxWindow *) 0 ;
30400 int arg2 ;
30401 bool result;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 char *kwnames[] = {
30405 (char *) "self",(char *) "pages", NULL
30406 };
30407
30408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30410 if (SWIG_arg_fail(1)) SWIG_fail;
30411 {
30412 arg2 = (int)(SWIG_As_int(obj1));
30413 if (SWIG_arg_fail(2)) SWIG_fail;
30414 }
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (bool)(arg1)->ScrollPages(arg2);
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxWindow *arg1 = (wxWindow *) 0 ;
30434 bool result;
30435 PyObject * obj0 = 0 ;
30436 char *kwnames[] = {
30437 (char *) "self", NULL
30438 };
30439
30440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(1)) SWIG_fail;
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (bool)(arg1)->LineUp();
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxWindow *arg1 = (wxWindow *) 0 ;
30462 bool result;
30463 PyObject * obj0 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (bool)(arg1)->LineDown();
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 bool result;
30491 PyObject * obj0 = 0 ;
30492 char *kwnames[] = {
30493 (char *) "self", NULL
30494 };
30495
30496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30498 if (SWIG_arg_fail(1)) SWIG_fail;
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (bool)(arg1)->PageUp();
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxWindow *arg1 = (wxWindow *) 0 ;
30518 bool result;
30519 PyObject * obj0 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 result = (bool)(arg1)->PageDown();
30530
30531 wxPyEndAllowThreads(__tstate);
30532 if (PyErr_Occurred()) SWIG_fail;
30533 }
30534 {
30535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30536 }
30537 return resultobj;
30538 fail:
30539 return NULL;
30540 }
30541
30542
30543 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj;
30545 wxWindow *arg1 = (wxWindow *) 0 ;
30546 wxString *arg2 = 0 ;
30547 bool temp2 = false ;
30548 PyObject * obj0 = 0 ;
30549 PyObject * obj1 = 0 ;
30550 char *kwnames[] = {
30551 (char *) "self",(char *) "text", NULL
30552 };
30553
30554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30556 if (SWIG_arg_fail(1)) SWIG_fail;
30557 {
30558 arg2 = wxString_in_helper(obj1);
30559 if (arg2 == NULL) SWIG_fail;
30560 temp2 = true;
30561 }
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 (arg1)->SetHelpText((wxString const &)*arg2);
30565
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 Py_INCREF(Py_None); resultobj = Py_None;
30570 {
30571 if (temp2)
30572 delete arg2;
30573 }
30574 return resultobj;
30575 fail:
30576 {
30577 if (temp2)
30578 delete arg2;
30579 }
30580 return NULL;
30581 }
30582
30583
30584 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj;
30586 wxWindow *arg1 = (wxWindow *) 0 ;
30587 wxString *arg2 = 0 ;
30588 bool temp2 = false ;
30589 PyObject * obj0 = 0 ;
30590 PyObject * obj1 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self",(char *) "text", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 {
30599 arg2 = wxString_in_helper(obj1);
30600 if (arg2 == NULL) SWIG_fail;
30601 temp2 = true;
30602 }
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30606
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 Py_INCREF(Py_None); resultobj = Py_None;
30611 {
30612 if (temp2)
30613 delete arg2;
30614 }
30615 return resultobj;
30616 fail:
30617 {
30618 if (temp2)
30619 delete arg2;
30620 }
30621 return NULL;
30622 }
30623
30624
30625 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj;
30627 wxWindow *arg1 = (wxWindow *) 0 ;
30628 wxString result;
30629 PyObject * obj0 = 0 ;
30630 char *kwnames[] = {
30631 (char *) "self", NULL
30632 };
30633
30634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30636 if (SWIG_arg_fail(1)) SWIG_fail;
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 result = ((wxWindow const *)arg1)->GetHelpText();
30640
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 {
30645 #if wxUSE_UNICODE
30646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30647 #else
30648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30649 #endif
30650 }
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 wxWindow *arg1 = (wxWindow *) 0 ;
30660 wxString *arg2 = 0 ;
30661 bool temp2 = false ;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self",(char *) "tip", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 {
30672 arg2 = wxString_in_helper(obj1);
30673 if (arg2 == NULL) SWIG_fail;
30674 temp2 = true;
30675 }
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 (arg1)->SetToolTip((wxString const &)*arg2);
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 Py_INCREF(Py_None); resultobj = Py_None;
30684 {
30685 if (temp2)
30686 delete arg2;
30687 }
30688 return resultobj;
30689 fail:
30690 {
30691 if (temp2)
30692 delete arg2;
30693 }
30694 return NULL;
30695 }
30696
30697
30698 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30699 PyObject *resultobj;
30700 wxWindow *arg1 = (wxWindow *) 0 ;
30701 wxToolTip *arg2 = (wxToolTip *) 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 char *kwnames[] = {
30705 (char *) "self",(char *) "tip", NULL
30706 };
30707
30708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30710 if (SWIG_arg_fail(1)) SWIG_fail;
30711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30712 if (SWIG_arg_fail(2)) SWIG_fail;
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 (arg1)->SetToolTip(arg2);
30716
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 Py_INCREF(Py_None); resultobj = Py_None;
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30728 PyObject *resultobj;
30729 wxWindow *arg1 = (wxWindow *) 0 ;
30730 wxToolTip *result;
30731 PyObject * obj0 = 0 ;
30732 char *kwnames[] = {
30733 (char *) "self", NULL
30734 };
30735
30736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30738 if (SWIG_arg_fail(1)) SWIG_fail;
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30742
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 {
30747 resultobj = wxPyMake_wxObject(result, 0);
30748 }
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30756 PyObject *resultobj;
30757 wxWindow *arg1 = (wxWindow *) 0 ;
30758 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30759 PyObject * obj0 = 0 ;
30760 PyObject * obj1 = 0 ;
30761 char *kwnames[] = {
30762 (char *) "self",(char *) "dropTarget", NULL
30763 };
30764
30765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30767 if (SWIG_arg_fail(1)) SWIG_fail;
30768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30769 if (SWIG_arg_fail(2)) SWIG_fail;
30770 {
30771 PyThreadState* __tstate = wxPyBeginAllowThreads();
30772 (arg1)->SetDropTarget(arg2);
30773
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 Py_INCREF(Py_None); resultobj = Py_None;
30778 return resultobj;
30779 fail:
30780 return NULL;
30781 }
30782
30783
30784 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30785 PyObject *resultobj;
30786 wxWindow *arg1 = (wxWindow *) 0 ;
30787 wxPyDropTarget *result;
30788 PyObject * obj0 = 0 ;
30789 char *kwnames[] = {
30790 (char *) "self", NULL
30791 };
30792
30793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30795 if (SWIG_arg_fail(1)) SWIG_fail;
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30799
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj;
30812 wxWindow *arg1 = (wxWindow *) 0 ;
30813 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 char *kwnames[] = {
30817 (char *) "self",(char *) "constraints", NULL
30818 };
30819
30820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(1)) SWIG_fail;
30823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(2)) SWIG_fail;
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 (arg1)->SetConstraints(arg2);
30828
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 Py_INCREF(Py_None); resultobj = Py_None;
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 wxLayoutConstraints *result;
30843 PyObject * obj0 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "self", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(1)) SWIG_fail;
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30866 PyObject *resultobj;
30867 wxWindow *arg1 = (wxWindow *) 0 ;
30868 bool arg2 ;
30869 PyObject * obj0 = 0 ;
30870 PyObject * obj1 = 0 ;
30871 char *kwnames[] = {
30872 (char *) "self",(char *) "autoLayout", NULL
30873 };
30874
30875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30877 if (SWIG_arg_fail(1)) SWIG_fail;
30878 {
30879 arg2 = (bool)(SWIG_As_bool(obj1));
30880 if (SWIG_arg_fail(2)) SWIG_fail;
30881 }
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 (arg1)->SetAutoLayout(arg2);
30885
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 Py_INCREF(Py_None); resultobj = Py_None;
30890 return resultobj;
30891 fail:
30892 return NULL;
30893 }
30894
30895
30896 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30897 PyObject *resultobj;
30898 wxWindow *arg1 = (wxWindow *) 0 ;
30899 bool result;
30900 PyObject * obj0 = 0 ;
30901 char *kwnames[] = {
30902 (char *) "self", NULL
30903 };
30904
30905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
30906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(1)) SWIG_fail;
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
30911
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 {
30916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30917 }
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj;
30926 wxWindow *arg1 = (wxWindow *) 0 ;
30927 bool result;
30928 PyObject * obj0 = 0 ;
30929 char *kwnames[] = {
30930 (char *) "self", NULL
30931 };
30932
30933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
30934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30935 if (SWIG_arg_fail(1)) SWIG_fail;
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 result = (bool)(arg1)->Layout();
30939
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 {
30944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxWindow *arg1 = (wxWindow *) 0 ;
30955 wxSizer *arg2 = (wxSizer *) 0 ;
30956 bool arg3 = (bool) true ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 PyObject * obj2 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
30962 };
30963
30964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
30965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30966 if (SWIG_arg_fail(1)) SWIG_fail;
30967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
30968 if (SWIG_arg_fail(2)) SWIG_fail;
30969 if (obj2) {
30970 {
30971 arg3 = (bool)(SWIG_As_bool(obj2));
30972 if (SWIG_arg_fail(3)) SWIG_fail;
30973 }
30974 }
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 (arg1)->SetSizer(arg2,arg3);
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_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
30990 PyObject *resultobj;
30991 wxWindow *arg1 = (wxWindow *) 0 ;
30992 wxSizer *arg2 = (wxSizer *) 0 ;
30993 bool arg3 = (bool) true ;
30994 PyObject * obj0 = 0 ;
30995 PyObject * obj1 = 0 ;
30996 PyObject * obj2 = 0 ;
30997 char *kwnames[] = {
30998 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
30999 };
31000
31001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31005 if (SWIG_arg_fail(2)) SWIG_fail;
31006 if (obj2) {
31007 {
31008 arg3 = (bool)(SWIG_As_bool(obj2));
31009 if (SWIG_arg_fail(3)) SWIG_fail;
31010 }
31011 }
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 (arg1)->SetSizerAndFit(arg2,arg3);
31015
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 Py_INCREF(Py_None); resultobj = Py_None;
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj;
31028 wxWindow *arg1 = (wxWindow *) 0 ;
31029 wxSizer *result;
31030 PyObject * obj0 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31041
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 {
31046 resultobj = wxPyMake_wxSizer(result, 0);
31047 }
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj;
31056 wxWindow *arg1 = (wxWindow *) 0 ;
31057 wxSizer *arg2 = (wxSizer *) 0 ;
31058 PyObject * obj0 = 0 ;
31059 PyObject * obj1 = 0 ;
31060 char *kwnames[] = {
31061 (char *) "self",(char *) "sizer", NULL
31062 };
31063
31064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31066 if (SWIG_arg_fail(1)) SWIG_fail;
31067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31068 if (SWIG_arg_fail(2)) SWIG_fail;
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 (arg1)->SetContainingSizer(arg2);
31072
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 Py_INCREF(Py_None); resultobj = Py_None;
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 wxSizer *result;
31087 PyObject * obj0 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31098
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 {
31103 resultobj = wxPyMake_wxSizer(result, 0);
31104 }
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj;
31113 wxWindow *arg1 = (wxWindow *) 0 ;
31114 PyObject * obj0 = 0 ;
31115 char *kwnames[] = {
31116 (char *) "self", NULL
31117 };
31118
31119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31121 if (SWIG_arg_fail(1)) SWIG_fail;
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 (arg1)->InheritAttributes();
31125
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 Py_INCREF(Py_None); resultobj = Py_None;
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31137 PyObject *resultobj;
31138 wxWindow *arg1 = (wxWindow *) 0 ;
31139 bool result;
31140 PyObject * obj0 = 0 ;
31141 char *kwnames[] = {
31142 (char *) "self", NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31147 if (SWIG_arg_fail(1)) SWIG_fail;
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31151
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 {
31156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31157 }
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31165 PyObject *obj;
31166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31167 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31168 Py_INCREF(obj);
31169 return Py_BuildValue((char *)"");
31170 }
31171 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj;
31173 long arg1 ;
31174 wxWindow *arg2 = (wxWindow *) NULL ;
31175 wxWindow *result;
31176 PyObject * obj0 = 0 ;
31177 PyObject * obj1 = 0 ;
31178 char *kwnames[] = {
31179 (char *) "id",(char *) "parent", NULL
31180 };
31181
31182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31183 {
31184 arg1 = (long)(SWIG_As_long(obj0));
31185 if (SWIG_arg_fail(1)) SWIG_fail;
31186 }
31187 if (obj1) {
31188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31189 if (SWIG_arg_fail(2)) SWIG_fail;
31190 }
31191 {
31192 if (!wxPyCheckForApp()) SWIG_fail;
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 resultobj = wxPyMake_wxObject(result, 0);
31201 }
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj;
31210 wxString *arg1 = 0 ;
31211 wxWindow *arg2 = (wxWindow *) NULL ;
31212 wxWindow *result;
31213 bool temp1 = false ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "name",(char *) "parent", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31221 {
31222 arg1 = wxString_in_helper(obj0);
31223 if (arg1 == NULL) SWIG_fail;
31224 temp1 = true;
31225 }
31226 if (obj1) {
31227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31228 if (SWIG_arg_fail(2)) SWIG_fail;
31229 }
31230 {
31231 if (!wxPyCheckForApp()) SWIG_fail;
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31234
31235 wxPyEndAllowThreads(__tstate);
31236 if (PyErr_Occurred()) SWIG_fail;
31237 }
31238 {
31239 resultobj = wxPyMake_wxObject(result, 0);
31240 }
31241 {
31242 if (temp1)
31243 delete arg1;
31244 }
31245 return resultobj;
31246 fail:
31247 {
31248 if (temp1)
31249 delete arg1;
31250 }
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxString *arg1 = 0 ;
31258 wxWindow *arg2 = (wxWindow *) NULL ;
31259 wxWindow *result;
31260 bool temp1 = false ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 char *kwnames[] = {
31264 (char *) "label",(char *) "parent", NULL
31265 };
31266
31267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31268 {
31269 arg1 = wxString_in_helper(obj0);
31270 if (arg1 == NULL) SWIG_fail;
31271 temp1 = true;
31272 }
31273 if (obj1) {
31274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31275 if (SWIG_arg_fail(2)) SWIG_fail;
31276 }
31277 {
31278 if (!wxPyCheckForApp()) SWIG_fail;
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31281
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 {
31286 resultobj = wxPyMake_wxObject(result, 0);
31287 }
31288 {
31289 if (temp1)
31290 delete arg1;
31291 }
31292 return resultobj;
31293 fail:
31294 {
31295 if (temp1)
31296 delete arg1;
31297 }
31298 return NULL;
31299 }
31300
31301
31302 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31303 PyObject *resultobj;
31304 wxWindow *arg1 = (wxWindow *) 0 ;
31305 unsigned long arg2 ;
31306 wxWindow *result;
31307 PyObject * obj0 = 0 ;
31308 PyObject * obj1 = 0 ;
31309 char *kwnames[] = {
31310 (char *) "parent",(char *) "_hWnd", NULL
31311 };
31312
31313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31315 if (SWIG_arg_fail(1)) SWIG_fail;
31316 {
31317 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31318 if (SWIG_arg_fail(2)) SWIG_fail;
31319 }
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31323
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 {
31328 resultobj = wxPyMake_wxObject(result, 0);
31329 }
31330 return resultobj;
31331 fail:
31332 return NULL;
31333 }
31334
31335
31336 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31337 PyObject *resultobj;
31338 wxValidator *result;
31339 char *kwnames[] = {
31340 NULL
31341 };
31342
31343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 result = (wxValidator *)new wxValidator();
31347
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj;
31360 wxValidator *arg1 = (wxValidator *) 0 ;
31361 wxValidator *result;
31362 PyObject * obj0 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31369 if (SWIG_arg_fail(1)) SWIG_fail;
31370 {
31371 PyThreadState* __tstate = wxPyBeginAllowThreads();
31372 result = (wxValidator *)(arg1)->Clone();
31373
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 {
31378 resultobj = wxPyMake_wxObject(result, 0);
31379 }
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31387 PyObject *resultobj;
31388 wxValidator *arg1 = (wxValidator *) 0 ;
31389 wxWindow *arg2 = (wxWindow *) 0 ;
31390 bool result;
31391 PyObject * obj0 = 0 ;
31392 PyObject * obj1 = 0 ;
31393 char *kwnames[] = {
31394 (char *) "self",(char *) "parent", NULL
31395 };
31396
31397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31399 if (SWIG_arg_fail(1)) SWIG_fail;
31400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31401 if (SWIG_arg_fail(2)) SWIG_fail;
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (bool)(arg1)->Validate(arg2);
31405
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 {
31410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31411 }
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj;
31420 wxValidator *arg1 = (wxValidator *) 0 ;
31421 bool result;
31422 PyObject * obj0 = 0 ;
31423 char *kwnames[] = {
31424 (char *) "self", NULL
31425 };
31426
31427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31429 if (SWIG_arg_fail(1)) SWIG_fail;
31430 {
31431 PyThreadState* __tstate = wxPyBeginAllowThreads();
31432 result = (bool)(arg1)->TransferToWindow();
31433
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 {
31438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31439 }
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj;
31448 wxValidator *arg1 = (wxValidator *) 0 ;
31449 bool result;
31450 PyObject * obj0 = 0 ;
31451 char *kwnames[] = {
31452 (char *) "self", NULL
31453 };
31454
31455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31457 if (SWIG_arg_fail(1)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (bool)(arg1)->TransferFromWindow();
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31475 PyObject *resultobj;
31476 wxValidator *arg1 = (wxValidator *) 0 ;
31477 wxWindow *result;
31478 PyObject * obj0 = 0 ;
31479 char *kwnames[] = {
31480 (char *) "self", NULL
31481 };
31482
31483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31485 if (SWIG_arg_fail(1)) SWIG_fail;
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 result = (wxWindow *)(arg1)->GetWindow();
31489
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 {
31494 resultobj = wxPyMake_wxObject(result, 0);
31495 }
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31503 PyObject *resultobj;
31504 wxValidator *arg1 = (wxValidator *) 0 ;
31505 wxWindow *arg2 = (wxWindow *) 0 ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 char *kwnames[] = {
31509 (char *) "self",(char *) "window", NULL
31510 };
31511
31512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31514 if (SWIG_arg_fail(1)) SWIG_fail;
31515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31516 if (SWIG_arg_fail(2)) SWIG_fail;
31517 {
31518 PyThreadState* __tstate = wxPyBeginAllowThreads();
31519 (arg1)->SetWindow(arg2);
31520
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 Py_INCREF(Py_None); resultobj = Py_None;
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31532 PyObject *resultobj;
31533 bool result;
31534 char *kwnames[] = {
31535 NULL
31536 };
31537
31538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 result = (bool)wxValidator::IsSilent();
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 {
31547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31548 }
31549 return resultobj;
31550 fail:
31551 return NULL;
31552 }
31553
31554
31555 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31556 PyObject *resultobj;
31557 int arg1 = (int) true ;
31558 PyObject * obj0 = 0 ;
31559 char *kwnames[] = {
31560 (char *) "doIt", NULL
31561 };
31562
31563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31564 if (obj0) {
31565 {
31566 arg1 = (int)(SWIG_As_int(obj0));
31567 if (SWIG_arg_fail(1)) SWIG_fail;
31568 }
31569 }
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 wxValidator::SetBellOnError(arg1);
31573
31574 wxPyEndAllowThreads(__tstate);
31575 if (PyErr_Occurred()) SWIG_fail;
31576 }
31577 Py_INCREF(Py_None); resultobj = Py_None;
31578 return resultobj;
31579 fail:
31580 return NULL;
31581 }
31582
31583
31584 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31585 PyObject *obj;
31586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31587 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31588 Py_INCREF(obj);
31589 return Py_BuildValue((char *)"");
31590 }
31591 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj;
31593 wxPyValidator *result;
31594 char *kwnames[] = {
31595 NULL
31596 };
31597
31598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (wxPyValidator *)new wxPyValidator();
31602
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31614 PyObject *resultobj;
31615 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31616 PyObject *arg2 = (PyObject *) 0 ;
31617 PyObject *arg3 = (PyObject *) 0 ;
31618 int arg4 = (int) true ;
31619 PyObject * obj0 = 0 ;
31620 PyObject * obj1 = 0 ;
31621 PyObject * obj2 = 0 ;
31622 PyObject * obj3 = 0 ;
31623 char *kwnames[] = {
31624 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31625 };
31626
31627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31629 if (SWIG_arg_fail(1)) SWIG_fail;
31630 arg2 = obj1;
31631 arg3 = obj2;
31632 if (obj3) {
31633 {
31634 arg4 = (int)(SWIG_As_int(obj3));
31635 if (SWIG_arg_fail(4)) SWIG_fail;
31636 }
31637 }
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31641
31642 wxPyEndAllowThreads(__tstate);
31643 if (PyErr_Occurred()) SWIG_fail;
31644 }
31645 Py_INCREF(Py_None); resultobj = Py_None;
31646 return resultobj;
31647 fail:
31648 return NULL;
31649 }
31650
31651
31652 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31653 PyObject *obj;
31654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31655 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31656 Py_INCREF(obj);
31657 return Py_BuildValue((char *)"");
31658 }
31659 static int _wrap_DefaultValidator_set(PyObject *) {
31660 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31661 return 1;
31662 }
31663
31664
31665 static PyObject *_wrap_DefaultValidator_get(void) {
31666 PyObject *pyobj;
31667
31668 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31669 return pyobj;
31670 }
31671
31672
31673 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31674 PyObject *resultobj;
31675 wxString const &arg1_defvalue = wxPyEmptyString ;
31676 wxString *arg1 = (wxString *) &arg1_defvalue ;
31677 long arg2 = (long) 0 ;
31678 wxMenu *result;
31679 bool temp1 = false ;
31680 PyObject * obj0 = 0 ;
31681 PyObject * obj1 = 0 ;
31682 char *kwnames[] = {
31683 (char *) "title",(char *) "style", NULL
31684 };
31685
31686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31687 if (obj0) {
31688 {
31689 arg1 = wxString_in_helper(obj0);
31690 if (arg1 == NULL) SWIG_fail;
31691 temp1 = true;
31692 }
31693 }
31694 if (obj1) {
31695 {
31696 arg2 = (long)(SWIG_As_long(obj1));
31697 if (SWIG_arg_fail(2)) SWIG_fail;
31698 }
31699 }
31700 {
31701 if (!wxPyCheckForApp()) SWIG_fail;
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31704
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31709 {
31710 if (temp1)
31711 delete arg1;
31712 }
31713 return resultobj;
31714 fail:
31715 {
31716 if (temp1)
31717 delete arg1;
31718 }
31719 return NULL;
31720 }
31721
31722
31723 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31724 PyObject *resultobj;
31725 wxMenu *arg1 = (wxMenu *) 0 ;
31726 int arg2 ;
31727 wxString *arg3 = 0 ;
31728 wxString const &arg4_defvalue = wxPyEmptyString ;
31729 wxString *arg4 = (wxString *) &arg4_defvalue ;
31730 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31731 wxMenuItem *result;
31732 bool temp3 = false ;
31733 bool temp4 = false ;
31734 PyObject * obj0 = 0 ;
31735 PyObject * obj1 = 0 ;
31736 PyObject * obj2 = 0 ;
31737 PyObject * obj3 = 0 ;
31738 PyObject * obj4 = 0 ;
31739 char *kwnames[] = {
31740 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31741 };
31742
31743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31745 if (SWIG_arg_fail(1)) SWIG_fail;
31746 {
31747 arg2 = (int)(SWIG_As_int(obj1));
31748 if (SWIG_arg_fail(2)) SWIG_fail;
31749 }
31750 {
31751 arg3 = wxString_in_helper(obj2);
31752 if (arg3 == NULL) SWIG_fail;
31753 temp3 = true;
31754 }
31755 if (obj3) {
31756 {
31757 arg4 = wxString_in_helper(obj3);
31758 if (arg4 == NULL) SWIG_fail;
31759 temp4 = true;
31760 }
31761 }
31762 if (obj4) {
31763 {
31764 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31765 if (SWIG_arg_fail(5)) SWIG_fail;
31766 }
31767 }
31768 {
31769 PyThreadState* __tstate = wxPyBeginAllowThreads();
31770 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31771
31772 wxPyEndAllowThreads(__tstate);
31773 if (PyErr_Occurred()) SWIG_fail;
31774 }
31775 {
31776 resultobj = wxPyMake_wxObject(result, 0);
31777 }
31778 {
31779 if (temp3)
31780 delete arg3;
31781 }
31782 {
31783 if (temp4)
31784 delete arg4;
31785 }
31786 return resultobj;
31787 fail:
31788 {
31789 if (temp3)
31790 delete arg3;
31791 }
31792 {
31793 if (temp4)
31794 delete arg4;
31795 }
31796 return NULL;
31797 }
31798
31799
31800 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31801 PyObject *resultobj;
31802 wxMenu *arg1 = (wxMenu *) 0 ;
31803 wxMenuItem *result;
31804 PyObject * obj0 = 0 ;
31805 char *kwnames[] = {
31806 (char *) "self", NULL
31807 };
31808
31809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31811 if (SWIG_arg_fail(1)) SWIG_fail;
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 result = (wxMenuItem *)(arg1)->AppendSeparator();
31815
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 {
31820 resultobj = wxPyMake_wxObject(result, 0);
31821 }
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31829 PyObject *resultobj;
31830 wxMenu *arg1 = (wxMenu *) 0 ;
31831 int arg2 ;
31832 wxString *arg3 = 0 ;
31833 wxString const &arg4_defvalue = wxPyEmptyString ;
31834 wxString *arg4 = (wxString *) &arg4_defvalue ;
31835 wxMenuItem *result;
31836 bool temp3 = false ;
31837 bool temp4 = false ;
31838 PyObject * obj0 = 0 ;
31839 PyObject * obj1 = 0 ;
31840 PyObject * obj2 = 0 ;
31841 PyObject * obj3 = 0 ;
31842 char *kwnames[] = {
31843 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31844 };
31845
31846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31848 if (SWIG_arg_fail(1)) SWIG_fail;
31849 {
31850 arg2 = (int)(SWIG_As_int(obj1));
31851 if (SWIG_arg_fail(2)) SWIG_fail;
31852 }
31853 {
31854 arg3 = wxString_in_helper(obj2);
31855 if (arg3 == NULL) SWIG_fail;
31856 temp3 = true;
31857 }
31858 if (obj3) {
31859 {
31860 arg4 = wxString_in_helper(obj3);
31861 if (arg4 == NULL) SWIG_fail;
31862 temp4 = true;
31863 }
31864 }
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31868
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 {
31873 resultobj = wxPyMake_wxObject(result, 0);
31874 }
31875 {
31876 if (temp3)
31877 delete arg3;
31878 }
31879 {
31880 if (temp4)
31881 delete arg4;
31882 }
31883 return resultobj;
31884 fail:
31885 {
31886 if (temp3)
31887 delete arg3;
31888 }
31889 {
31890 if (temp4)
31891 delete arg4;
31892 }
31893 return NULL;
31894 }
31895
31896
31897 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj;
31899 wxMenu *arg1 = (wxMenu *) 0 ;
31900 int arg2 ;
31901 wxString *arg3 = 0 ;
31902 wxString const &arg4_defvalue = wxPyEmptyString ;
31903 wxString *arg4 = (wxString *) &arg4_defvalue ;
31904 wxMenuItem *result;
31905 bool temp3 = false ;
31906 bool temp4 = false ;
31907 PyObject * obj0 = 0 ;
31908 PyObject * obj1 = 0 ;
31909 PyObject * obj2 = 0 ;
31910 PyObject * obj3 = 0 ;
31911 char *kwnames[] = {
31912 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31913 };
31914
31915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31917 if (SWIG_arg_fail(1)) SWIG_fail;
31918 {
31919 arg2 = (int)(SWIG_As_int(obj1));
31920 if (SWIG_arg_fail(2)) SWIG_fail;
31921 }
31922 {
31923 arg3 = wxString_in_helper(obj2);
31924 if (arg3 == NULL) SWIG_fail;
31925 temp3 = true;
31926 }
31927 if (obj3) {
31928 {
31929 arg4 = wxString_in_helper(obj3);
31930 if (arg4 == NULL) SWIG_fail;
31931 temp4 = true;
31932 }
31933 }
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31937
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 {
31942 resultobj = wxPyMake_wxObject(result, 0);
31943 }
31944 {
31945 if (temp3)
31946 delete arg3;
31947 }
31948 {
31949 if (temp4)
31950 delete arg4;
31951 }
31952 return resultobj;
31953 fail:
31954 {
31955 if (temp3)
31956 delete arg3;
31957 }
31958 {
31959 if (temp4)
31960 delete arg4;
31961 }
31962 return NULL;
31963 }
31964
31965
31966 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj;
31968 wxMenu *arg1 = (wxMenu *) 0 ;
31969 int arg2 ;
31970 wxString *arg3 = 0 ;
31971 wxMenu *arg4 = (wxMenu *) 0 ;
31972 wxString const &arg5_defvalue = wxPyEmptyString ;
31973 wxString *arg5 = (wxString *) &arg5_defvalue ;
31974 wxMenuItem *result;
31975 bool temp3 = false ;
31976 bool temp5 = false ;
31977 PyObject * obj0 = 0 ;
31978 PyObject * obj1 = 0 ;
31979 PyObject * obj2 = 0 ;
31980 PyObject * obj3 = 0 ;
31981 PyObject * obj4 = 0 ;
31982 char *kwnames[] = {
31983 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
31984 };
31985
31986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31988 if (SWIG_arg_fail(1)) SWIG_fail;
31989 {
31990 arg2 = (int)(SWIG_As_int(obj1));
31991 if (SWIG_arg_fail(2)) SWIG_fail;
31992 }
31993 {
31994 arg3 = wxString_in_helper(obj2);
31995 if (arg3 == NULL) SWIG_fail;
31996 temp3 = true;
31997 }
31998 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31999 if (SWIG_arg_fail(4)) SWIG_fail;
32000 if (obj4) {
32001 {
32002 arg5 = wxString_in_helper(obj4);
32003 if (arg5 == NULL) SWIG_fail;
32004 temp5 = true;
32005 }
32006 }
32007 {
32008 PyThreadState* __tstate = wxPyBeginAllowThreads();
32009 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32010
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 {
32015 resultobj = wxPyMake_wxObject(result, 0);
32016 }
32017 {
32018 if (temp3)
32019 delete arg3;
32020 }
32021 {
32022 if (temp5)
32023 delete arg5;
32024 }
32025 return resultobj;
32026 fail:
32027 {
32028 if (temp3)
32029 delete arg3;
32030 }
32031 {
32032 if (temp5)
32033 delete arg5;
32034 }
32035 return NULL;
32036 }
32037
32038
32039 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj;
32041 wxMenu *arg1 = (wxMenu *) 0 ;
32042 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32043 wxMenuItem *result;
32044 PyObject * obj0 = 0 ;
32045 PyObject * obj1 = 0 ;
32046 char *kwnames[] = {
32047 (char *) "self",(char *) "item", NULL
32048 };
32049
32050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(1)) SWIG_fail;
32053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32054 if (SWIG_arg_fail(2)) SWIG_fail;
32055 {
32056 PyThreadState* __tstate = wxPyBeginAllowThreads();
32057 result = (wxMenuItem *)(arg1)->Append(arg2);
32058
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 {
32063 resultobj = wxPyMake_wxObject(result, 0);
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj;
32073 wxMenu *arg1 = (wxMenu *) 0 ;
32074 PyObject * obj0 = 0 ;
32075 char *kwnames[] = {
32076 (char *) "self", NULL
32077 };
32078
32079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32081 if (SWIG_arg_fail(1)) SWIG_fail;
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 (arg1)->Break();
32085
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 Py_INCREF(Py_None); resultobj = Py_None;
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32097 PyObject *resultobj;
32098 wxMenu *arg1 = (wxMenu *) 0 ;
32099 size_t arg2 ;
32100 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32101 wxMenuItem *result;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 PyObject * obj2 = 0 ;
32105 char *kwnames[] = {
32106 (char *) "self",(char *) "pos",(char *) "item", NULL
32107 };
32108
32109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32111 if (SWIG_arg_fail(1)) SWIG_fail;
32112 {
32113 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32114 if (SWIG_arg_fail(2)) SWIG_fail;
32115 }
32116 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32117 if (SWIG_arg_fail(3)) SWIG_fail;
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32121
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 {
32126 resultobj = wxPyMake_wxObject(result, 0);
32127 }
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32135 PyObject *resultobj;
32136 wxMenu *arg1 = (wxMenu *) 0 ;
32137 size_t arg2 ;
32138 int arg3 ;
32139 wxString *arg4 = 0 ;
32140 wxString const &arg5_defvalue = wxPyEmptyString ;
32141 wxString *arg5 = (wxString *) &arg5_defvalue ;
32142 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32143 wxMenuItem *result;
32144 bool temp4 = false ;
32145 bool temp5 = false ;
32146 PyObject * obj0 = 0 ;
32147 PyObject * obj1 = 0 ;
32148 PyObject * obj2 = 0 ;
32149 PyObject * obj3 = 0 ;
32150 PyObject * obj4 = 0 ;
32151 PyObject * obj5 = 0 ;
32152 char *kwnames[] = {
32153 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32154 };
32155
32156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32158 if (SWIG_arg_fail(1)) SWIG_fail;
32159 {
32160 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32161 if (SWIG_arg_fail(2)) SWIG_fail;
32162 }
32163 {
32164 arg3 = (int)(SWIG_As_int(obj2));
32165 if (SWIG_arg_fail(3)) SWIG_fail;
32166 }
32167 {
32168 arg4 = wxString_in_helper(obj3);
32169 if (arg4 == NULL) SWIG_fail;
32170 temp4 = true;
32171 }
32172 if (obj4) {
32173 {
32174 arg5 = wxString_in_helper(obj4);
32175 if (arg5 == NULL) SWIG_fail;
32176 temp5 = true;
32177 }
32178 }
32179 if (obj5) {
32180 {
32181 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32182 if (SWIG_arg_fail(6)) SWIG_fail;
32183 }
32184 }
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32188
32189 wxPyEndAllowThreads(__tstate);
32190 if (PyErr_Occurred()) SWIG_fail;
32191 }
32192 {
32193 resultobj = wxPyMake_wxObject(result, 0);
32194 }
32195 {
32196 if (temp4)
32197 delete arg4;
32198 }
32199 {
32200 if (temp5)
32201 delete arg5;
32202 }
32203 return resultobj;
32204 fail:
32205 {
32206 if (temp4)
32207 delete arg4;
32208 }
32209 {
32210 if (temp5)
32211 delete arg5;
32212 }
32213 return NULL;
32214 }
32215
32216
32217 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32218 PyObject *resultobj;
32219 wxMenu *arg1 = (wxMenu *) 0 ;
32220 size_t arg2 ;
32221 wxMenuItem *result;
32222 PyObject * obj0 = 0 ;
32223 PyObject * obj1 = 0 ;
32224 char *kwnames[] = {
32225 (char *) "self",(char *) "pos", NULL
32226 };
32227
32228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32230 if (SWIG_arg_fail(1)) SWIG_fail;
32231 {
32232 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32233 if (SWIG_arg_fail(2)) SWIG_fail;
32234 }
32235 {
32236 PyThreadState* __tstate = wxPyBeginAllowThreads();
32237 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32238
32239 wxPyEndAllowThreads(__tstate);
32240 if (PyErr_Occurred()) SWIG_fail;
32241 }
32242 {
32243 resultobj = wxPyMake_wxObject(result, 0);
32244 }
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32252 PyObject *resultobj;
32253 wxMenu *arg1 = (wxMenu *) 0 ;
32254 size_t arg2 ;
32255 int arg3 ;
32256 wxString *arg4 = 0 ;
32257 wxString const &arg5_defvalue = wxPyEmptyString ;
32258 wxString *arg5 = (wxString *) &arg5_defvalue ;
32259 wxMenuItem *result;
32260 bool temp4 = false ;
32261 bool temp5 = false ;
32262 PyObject * obj0 = 0 ;
32263 PyObject * obj1 = 0 ;
32264 PyObject * obj2 = 0 ;
32265 PyObject * obj3 = 0 ;
32266 PyObject * obj4 = 0 ;
32267 char *kwnames[] = {
32268 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32269 };
32270
32271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32273 if (SWIG_arg_fail(1)) SWIG_fail;
32274 {
32275 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32276 if (SWIG_arg_fail(2)) SWIG_fail;
32277 }
32278 {
32279 arg3 = (int)(SWIG_As_int(obj2));
32280 if (SWIG_arg_fail(3)) SWIG_fail;
32281 }
32282 {
32283 arg4 = wxString_in_helper(obj3);
32284 if (arg4 == NULL) SWIG_fail;
32285 temp4 = true;
32286 }
32287 if (obj4) {
32288 {
32289 arg5 = wxString_in_helper(obj4);
32290 if (arg5 == NULL) SWIG_fail;
32291 temp5 = true;
32292 }
32293 }
32294 {
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32297
32298 wxPyEndAllowThreads(__tstate);
32299 if (PyErr_Occurred()) SWIG_fail;
32300 }
32301 {
32302 resultobj = wxPyMake_wxObject(result, 0);
32303 }
32304 {
32305 if (temp4)
32306 delete arg4;
32307 }
32308 {
32309 if (temp5)
32310 delete arg5;
32311 }
32312 return resultobj;
32313 fail:
32314 {
32315 if (temp4)
32316 delete arg4;
32317 }
32318 {
32319 if (temp5)
32320 delete arg5;
32321 }
32322 return NULL;
32323 }
32324
32325
32326 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32327 PyObject *resultobj;
32328 wxMenu *arg1 = (wxMenu *) 0 ;
32329 size_t arg2 ;
32330 int arg3 ;
32331 wxString *arg4 = 0 ;
32332 wxString const &arg5_defvalue = wxPyEmptyString ;
32333 wxString *arg5 = (wxString *) &arg5_defvalue ;
32334 wxMenuItem *result;
32335 bool temp4 = false ;
32336 bool temp5 = false ;
32337 PyObject * obj0 = 0 ;
32338 PyObject * obj1 = 0 ;
32339 PyObject * obj2 = 0 ;
32340 PyObject * obj3 = 0 ;
32341 PyObject * obj4 = 0 ;
32342 char *kwnames[] = {
32343 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32344 };
32345
32346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32348 if (SWIG_arg_fail(1)) SWIG_fail;
32349 {
32350 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32351 if (SWIG_arg_fail(2)) SWIG_fail;
32352 }
32353 {
32354 arg3 = (int)(SWIG_As_int(obj2));
32355 if (SWIG_arg_fail(3)) SWIG_fail;
32356 }
32357 {
32358 arg4 = wxString_in_helper(obj3);
32359 if (arg4 == NULL) SWIG_fail;
32360 temp4 = true;
32361 }
32362 if (obj4) {
32363 {
32364 arg5 = wxString_in_helper(obj4);
32365 if (arg5 == NULL) SWIG_fail;
32366 temp5 = true;
32367 }
32368 }
32369 {
32370 PyThreadState* __tstate = wxPyBeginAllowThreads();
32371 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32372
32373 wxPyEndAllowThreads(__tstate);
32374 if (PyErr_Occurred()) SWIG_fail;
32375 }
32376 {
32377 resultobj = wxPyMake_wxObject(result, 0);
32378 }
32379 {
32380 if (temp4)
32381 delete arg4;
32382 }
32383 {
32384 if (temp5)
32385 delete arg5;
32386 }
32387 return resultobj;
32388 fail:
32389 {
32390 if (temp4)
32391 delete arg4;
32392 }
32393 {
32394 if (temp5)
32395 delete arg5;
32396 }
32397 return NULL;
32398 }
32399
32400
32401 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32402 PyObject *resultobj;
32403 wxMenu *arg1 = (wxMenu *) 0 ;
32404 size_t arg2 ;
32405 int arg3 ;
32406 wxString *arg4 = 0 ;
32407 wxMenu *arg5 = (wxMenu *) 0 ;
32408 wxString const &arg6_defvalue = wxPyEmptyString ;
32409 wxString *arg6 = (wxString *) &arg6_defvalue ;
32410 wxMenuItem *result;
32411 bool temp4 = false ;
32412 bool temp6 = false ;
32413 PyObject * obj0 = 0 ;
32414 PyObject * obj1 = 0 ;
32415 PyObject * obj2 = 0 ;
32416 PyObject * obj3 = 0 ;
32417 PyObject * obj4 = 0 ;
32418 PyObject * obj5 = 0 ;
32419 char *kwnames[] = {
32420 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32421 };
32422
32423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32425 if (SWIG_arg_fail(1)) SWIG_fail;
32426 {
32427 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32428 if (SWIG_arg_fail(2)) SWIG_fail;
32429 }
32430 {
32431 arg3 = (int)(SWIG_As_int(obj2));
32432 if (SWIG_arg_fail(3)) SWIG_fail;
32433 }
32434 {
32435 arg4 = wxString_in_helper(obj3);
32436 if (arg4 == NULL) SWIG_fail;
32437 temp4 = true;
32438 }
32439 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32440 if (SWIG_arg_fail(5)) SWIG_fail;
32441 if (obj5) {
32442 {
32443 arg6 = wxString_in_helper(obj5);
32444 if (arg6 == NULL) SWIG_fail;
32445 temp6 = true;
32446 }
32447 }
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32451
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 {
32456 resultobj = wxPyMake_wxObject(result, 0);
32457 }
32458 {
32459 if (temp4)
32460 delete arg4;
32461 }
32462 {
32463 if (temp6)
32464 delete arg6;
32465 }
32466 return resultobj;
32467 fail:
32468 {
32469 if (temp4)
32470 delete arg4;
32471 }
32472 {
32473 if (temp6)
32474 delete arg6;
32475 }
32476 return NULL;
32477 }
32478
32479
32480 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32481 PyObject *resultobj;
32482 wxMenu *arg1 = (wxMenu *) 0 ;
32483 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32484 wxMenuItem *result;
32485 PyObject * obj0 = 0 ;
32486 PyObject * obj1 = 0 ;
32487 char *kwnames[] = {
32488 (char *) "self",(char *) "item", NULL
32489 };
32490
32491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32493 if (SWIG_arg_fail(1)) SWIG_fail;
32494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32495 if (SWIG_arg_fail(2)) SWIG_fail;
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32499
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 {
32504 resultobj = wxPyMake_wxObject(result, 0);
32505 }
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj;
32514 wxMenu *arg1 = (wxMenu *) 0 ;
32515 int arg2 ;
32516 wxString *arg3 = 0 ;
32517 wxString const &arg4_defvalue = wxPyEmptyString ;
32518 wxString *arg4 = (wxString *) &arg4_defvalue ;
32519 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32520 wxMenuItem *result;
32521 bool temp3 = false ;
32522 bool temp4 = false ;
32523 PyObject * obj0 = 0 ;
32524 PyObject * obj1 = 0 ;
32525 PyObject * obj2 = 0 ;
32526 PyObject * obj3 = 0 ;
32527 PyObject * obj4 = 0 ;
32528 char *kwnames[] = {
32529 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32530 };
32531
32532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32534 if (SWIG_arg_fail(1)) SWIG_fail;
32535 {
32536 arg2 = (int)(SWIG_As_int(obj1));
32537 if (SWIG_arg_fail(2)) SWIG_fail;
32538 }
32539 {
32540 arg3 = wxString_in_helper(obj2);
32541 if (arg3 == NULL) SWIG_fail;
32542 temp3 = true;
32543 }
32544 if (obj3) {
32545 {
32546 arg4 = wxString_in_helper(obj3);
32547 if (arg4 == NULL) SWIG_fail;
32548 temp4 = true;
32549 }
32550 }
32551 if (obj4) {
32552 {
32553 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32554 if (SWIG_arg_fail(5)) SWIG_fail;
32555 }
32556 }
32557 {
32558 PyThreadState* __tstate = wxPyBeginAllowThreads();
32559 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32560
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 {
32565 resultobj = wxPyMake_wxObject(result, 0);
32566 }
32567 {
32568 if (temp3)
32569 delete arg3;
32570 }
32571 {
32572 if (temp4)
32573 delete arg4;
32574 }
32575 return resultobj;
32576 fail:
32577 {
32578 if (temp3)
32579 delete arg3;
32580 }
32581 {
32582 if (temp4)
32583 delete arg4;
32584 }
32585 return NULL;
32586 }
32587
32588
32589 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32590 PyObject *resultobj;
32591 wxMenu *arg1 = (wxMenu *) 0 ;
32592 wxMenuItem *result;
32593 PyObject * obj0 = 0 ;
32594 char *kwnames[] = {
32595 (char *) "self", NULL
32596 };
32597
32598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32600 if (SWIG_arg_fail(1)) SWIG_fail;
32601 {
32602 PyThreadState* __tstate = wxPyBeginAllowThreads();
32603 result = (wxMenuItem *)(arg1)->PrependSeparator();
32604
32605 wxPyEndAllowThreads(__tstate);
32606 if (PyErr_Occurred()) SWIG_fail;
32607 }
32608 {
32609 resultobj = wxPyMake_wxObject(result, 0);
32610 }
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj;
32619 wxMenu *arg1 = (wxMenu *) 0 ;
32620 int arg2 ;
32621 wxString *arg3 = 0 ;
32622 wxString const &arg4_defvalue = wxPyEmptyString ;
32623 wxString *arg4 = (wxString *) &arg4_defvalue ;
32624 wxMenuItem *result;
32625 bool temp3 = false ;
32626 bool temp4 = false ;
32627 PyObject * obj0 = 0 ;
32628 PyObject * obj1 = 0 ;
32629 PyObject * obj2 = 0 ;
32630 PyObject * obj3 = 0 ;
32631 char *kwnames[] = {
32632 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32633 };
32634
32635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32637 if (SWIG_arg_fail(1)) SWIG_fail;
32638 {
32639 arg2 = (int)(SWIG_As_int(obj1));
32640 if (SWIG_arg_fail(2)) SWIG_fail;
32641 }
32642 {
32643 arg3 = wxString_in_helper(obj2);
32644 if (arg3 == NULL) SWIG_fail;
32645 temp3 = true;
32646 }
32647 if (obj3) {
32648 {
32649 arg4 = wxString_in_helper(obj3);
32650 if (arg4 == NULL) SWIG_fail;
32651 temp4 = true;
32652 }
32653 }
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32657
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 {
32662 resultobj = wxPyMake_wxObject(result, 0);
32663 }
32664 {
32665 if (temp3)
32666 delete arg3;
32667 }
32668 {
32669 if (temp4)
32670 delete arg4;
32671 }
32672 return resultobj;
32673 fail:
32674 {
32675 if (temp3)
32676 delete arg3;
32677 }
32678 {
32679 if (temp4)
32680 delete arg4;
32681 }
32682 return NULL;
32683 }
32684
32685
32686 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj;
32688 wxMenu *arg1 = (wxMenu *) 0 ;
32689 int arg2 ;
32690 wxString *arg3 = 0 ;
32691 wxString const &arg4_defvalue = wxPyEmptyString ;
32692 wxString *arg4 = (wxString *) &arg4_defvalue ;
32693 wxMenuItem *result;
32694 bool temp3 = false ;
32695 bool temp4 = false ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 PyObject * obj2 = 0 ;
32699 PyObject * obj3 = 0 ;
32700 char *kwnames[] = {
32701 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32702 };
32703
32704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32706 if (SWIG_arg_fail(1)) SWIG_fail;
32707 {
32708 arg2 = (int)(SWIG_As_int(obj1));
32709 if (SWIG_arg_fail(2)) SWIG_fail;
32710 }
32711 {
32712 arg3 = wxString_in_helper(obj2);
32713 if (arg3 == NULL) SWIG_fail;
32714 temp3 = true;
32715 }
32716 if (obj3) {
32717 {
32718 arg4 = wxString_in_helper(obj3);
32719 if (arg4 == NULL) SWIG_fail;
32720 temp4 = true;
32721 }
32722 }
32723 {
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32726
32727 wxPyEndAllowThreads(__tstate);
32728 if (PyErr_Occurred()) SWIG_fail;
32729 }
32730 {
32731 resultobj = wxPyMake_wxObject(result, 0);
32732 }
32733 {
32734 if (temp3)
32735 delete arg3;
32736 }
32737 {
32738 if (temp4)
32739 delete arg4;
32740 }
32741 return resultobj;
32742 fail:
32743 {
32744 if (temp3)
32745 delete arg3;
32746 }
32747 {
32748 if (temp4)
32749 delete arg4;
32750 }
32751 return NULL;
32752 }
32753
32754
32755 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32756 PyObject *resultobj;
32757 wxMenu *arg1 = (wxMenu *) 0 ;
32758 int arg2 ;
32759 wxString *arg3 = 0 ;
32760 wxMenu *arg4 = (wxMenu *) 0 ;
32761 wxString const &arg5_defvalue = wxPyEmptyString ;
32762 wxString *arg5 = (wxString *) &arg5_defvalue ;
32763 wxMenuItem *result;
32764 bool temp3 = false ;
32765 bool temp5 = false ;
32766 PyObject * obj0 = 0 ;
32767 PyObject * obj1 = 0 ;
32768 PyObject * obj2 = 0 ;
32769 PyObject * obj3 = 0 ;
32770 PyObject * obj4 = 0 ;
32771 char *kwnames[] = {
32772 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32773 };
32774
32775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32777 if (SWIG_arg_fail(1)) SWIG_fail;
32778 {
32779 arg2 = (int)(SWIG_As_int(obj1));
32780 if (SWIG_arg_fail(2)) SWIG_fail;
32781 }
32782 {
32783 arg3 = wxString_in_helper(obj2);
32784 if (arg3 == NULL) SWIG_fail;
32785 temp3 = true;
32786 }
32787 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32788 if (SWIG_arg_fail(4)) SWIG_fail;
32789 if (obj4) {
32790 {
32791 arg5 = wxString_in_helper(obj4);
32792 if (arg5 == NULL) SWIG_fail;
32793 temp5 = true;
32794 }
32795 }
32796 {
32797 PyThreadState* __tstate = wxPyBeginAllowThreads();
32798 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32799
32800 wxPyEndAllowThreads(__tstate);
32801 if (PyErr_Occurred()) SWIG_fail;
32802 }
32803 {
32804 resultobj = wxPyMake_wxObject(result, 0);
32805 }
32806 {
32807 if (temp3)
32808 delete arg3;
32809 }
32810 {
32811 if (temp5)
32812 delete arg5;
32813 }
32814 return resultobj;
32815 fail:
32816 {
32817 if (temp3)
32818 delete arg3;
32819 }
32820 {
32821 if (temp5)
32822 delete arg5;
32823 }
32824 return NULL;
32825 }
32826
32827
32828 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32829 PyObject *resultobj;
32830 wxMenu *arg1 = (wxMenu *) 0 ;
32831 int arg2 ;
32832 wxMenuItem *result;
32833 PyObject * obj0 = 0 ;
32834 PyObject * obj1 = 0 ;
32835 char *kwnames[] = {
32836 (char *) "self",(char *) "id", NULL
32837 };
32838
32839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32841 if (SWIG_arg_fail(1)) SWIG_fail;
32842 {
32843 arg2 = (int)(SWIG_As_int(obj1));
32844 if (SWIG_arg_fail(2)) SWIG_fail;
32845 }
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 result = (wxMenuItem *)(arg1)->Remove(arg2);
32849
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 {
32854 resultobj = wxPyMake_wxObject(result, 0);
32855 }
32856 return resultobj;
32857 fail:
32858 return NULL;
32859 }
32860
32861
32862 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32863 PyObject *resultobj;
32864 wxMenu *arg1 = (wxMenu *) 0 ;
32865 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32866 wxMenuItem *result;
32867 PyObject * obj0 = 0 ;
32868 PyObject * obj1 = 0 ;
32869 char *kwnames[] = {
32870 (char *) "self",(char *) "item", NULL
32871 };
32872
32873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(1)) SWIG_fail;
32876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32877 if (SWIG_arg_fail(2)) SWIG_fail;
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 result = (wxMenuItem *)(arg1)->Remove(arg2);
32881
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 {
32886 resultobj = wxPyMake_wxObject(result, 0);
32887 }
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
32895 PyObject *resultobj;
32896 wxMenu *arg1 = (wxMenu *) 0 ;
32897 int arg2 ;
32898 bool result;
32899 PyObject * obj0 = 0 ;
32900 PyObject * obj1 = 0 ;
32901 char *kwnames[] = {
32902 (char *) "self",(char *) "id", NULL
32903 };
32904
32905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
32906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32907 if (SWIG_arg_fail(1)) SWIG_fail;
32908 {
32909 arg2 = (int)(SWIG_As_int(obj1));
32910 if (SWIG_arg_fail(2)) SWIG_fail;
32911 }
32912 {
32913 PyThreadState* __tstate = wxPyBeginAllowThreads();
32914 result = (bool)(arg1)->Delete(arg2);
32915
32916 wxPyEndAllowThreads(__tstate);
32917 if (PyErr_Occurred()) SWIG_fail;
32918 }
32919 {
32920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32921 }
32922 return resultobj;
32923 fail:
32924 return NULL;
32925 }
32926
32927
32928 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
32929 PyObject *resultobj;
32930 wxMenu *arg1 = (wxMenu *) 0 ;
32931 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32932 bool result;
32933 PyObject * obj0 = 0 ;
32934 PyObject * obj1 = 0 ;
32935 char *kwnames[] = {
32936 (char *) "self",(char *) "item", NULL
32937 };
32938
32939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
32940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32941 if (SWIG_arg_fail(1)) SWIG_fail;
32942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32943 if (SWIG_arg_fail(2)) SWIG_fail;
32944 {
32945 PyThreadState* __tstate = wxPyBeginAllowThreads();
32946 result = (bool)(arg1)->Delete(arg2);
32947
32948 wxPyEndAllowThreads(__tstate);
32949 if (PyErr_Occurred()) SWIG_fail;
32950 }
32951 {
32952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32953 }
32954 return resultobj;
32955 fail:
32956 return NULL;
32957 }
32958
32959
32960 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
32961 PyObject *resultobj;
32962 wxMenu *arg1 = (wxMenu *) 0 ;
32963 PyObject * obj0 = 0 ;
32964 char *kwnames[] = {
32965 (char *) "self", NULL
32966 };
32967
32968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
32969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32970 if (SWIG_arg_fail(1)) SWIG_fail;
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 wxMenu_Destroy(arg1);
32974
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 Py_INCREF(Py_None); resultobj = Py_None;
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
32986 PyObject *resultobj;
32987 wxMenu *arg1 = (wxMenu *) 0 ;
32988 int arg2 ;
32989 bool result;
32990 PyObject * obj0 = 0 ;
32991 PyObject * obj1 = 0 ;
32992 char *kwnames[] = {
32993 (char *) "self",(char *) "id", NULL
32994 };
32995
32996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
32997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32998 if (SWIG_arg_fail(1)) SWIG_fail;
32999 {
33000 arg2 = (int)(SWIG_As_int(obj1));
33001 if (SWIG_arg_fail(2)) SWIG_fail;
33002 }
33003 {
33004 PyThreadState* __tstate = wxPyBeginAllowThreads();
33005 result = (bool)(arg1)->Destroy(arg2);
33006
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 {
33011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33012 }
33013 return resultobj;
33014 fail:
33015 return NULL;
33016 }
33017
33018
33019 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33020 PyObject *resultobj;
33021 wxMenu *arg1 = (wxMenu *) 0 ;
33022 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33023 bool result;
33024 PyObject * obj0 = 0 ;
33025 PyObject * obj1 = 0 ;
33026 char *kwnames[] = {
33027 (char *) "self",(char *) "item", NULL
33028 };
33029
33030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33032 if (SWIG_arg_fail(1)) SWIG_fail;
33033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33034 if (SWIG_arg_fail(2)) SWIG_fail;
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 result = (bool)(arg1)->Destroy(arg2);
33038
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 {
33043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33044 }
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33052 PyObject *resultobj;
33053 wxMenu *arg1 = (wxMenu *) 0 ;
33054 size_t result;
33055 PyObject * obj0 = 0 ;
33056 char *kwnames[] = {
33057 (char *) "self", NULL
33058 };
33059
33060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33062 if (SWIG_arg_fail(1)) SWIG_fail;
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33066
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 {
33071 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33072 }
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj;
33081 wxMenu *arg1 = (wxMenu *) 0 ;
33082 PyObject *result;
33083 PyObject * obj0 = 0 ;
33084 char *kwnames[] = {
33085 (char *) "self", NULL
33086 };
33087
33088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33090 if (SWIG_arg_fail(1)) SWIG_fail;
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33094
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = result;
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj;
33107 wxMenu *arg1 = (wxMenu *) 0 ;
33108 wxString *arg2 = 0 ;
33109 int result;
33110 bool temp2 = false ;
33111 PyObject * obj0 = 0 ;
33112 PyObject * obj1 = 0 ;
33113 char *kwnames[] = {
33114 (char *) "self",(char *) "item", NULL
33115 };
33116
33117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33119 if (SWIG_arg_fail(1)) SWIG_fail;
33120 {
33121 arg2 = wxString_in_helper(obj1);
33122 if (arg2 == NULL) SWIG_fail;
33123 temp2 = true;
33124 }
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33128
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 {
33133 resultobj = SWIG_From_int((int)(result));
33134 }
33135 {
33136 if (temp2)
33137 delete arg2;
33138 }
33139 return resultobj;
33140 fail:
33141 {
33142 if (temp2)
33143 delete arg2;
33144 }
33145 return NULL;
33146 }
33147
33148
33149 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33150 PyObject *resultobj;
33151 wxMenu *arg1 = (wxMenu *) 0 ;
33152 int arg2 ;
33153 wxMenuItem *result;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char *kwnames[] = {
33157 (char *) "self",(char *) "id", NULL
33158 };
33159
33160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33162 if (SWIG_arg_fail(1)) SWIG_fail;
33163 {
33164 arg2 = (int)(SWIG_As_int(obj1));
33165 if (SWIG_arg_fail(2)) SWIG_fail;
33166 }
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33170
33171 wxPyEndAllowThreads(__tstate);
33172 if (PyErr_Occurred()) SWIG_fail;
33173 }
33174 {
33175 resultobj = wxPyMake_wxObject(result, 0);
33176 }
33177 return resultobj;
33178 fail:
33179 return NULL;
33180 }
33181
33182
33183 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33184 PyObject *resultobj;
33185 wxMenu *arg1 = (wxMenu *) 0 ;
33186 size_t arg2 ;
33187 wxMenuItem *result;
33188 PyObject * obj0 = 0 ;
33189 PyObject * obj1 = 0 ;
33190 char *kwnames[] = {
33191 (char *) "self",(char *) "position", NULL
33192 };
33193
33194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33196 if (SWIG_arg_fail(1)) SWIG_fail;
33197 {
33198 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33199 if (SWIG_arg_fail(2)) SWIG_fail;
33200 }
33201 {
33202 PyThreadState* __tstate = wxPyBeginAllowThreads();
33203 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33204
33205 wxPyEndAllowThreads(__tstate);
33206 if (PyErr_Occurred()) SWIG_fail;
33207 }
33208 {
33209 resultobj = wxPyMake_wxObject(result, 0);
33210 }
33211 return resultobj;
33212 fail:
33213 return NULL;
33214 }
33215
33216
33217 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33218 PyObject *resultobj;
33219 wxMenu *arg1 = (wxMenu *) 0 ;
33220 int arg2 ;
33221 bool arg3 ;
33222 PyObject * obj0 = 0 ;
33223 PyObject * obj1 = 0 ;
33224 PyObject * obj2 = 0 ;
33225 char *kwnames[] = {
33226 (char *) "self",(char *) "id",(char *) "enable", NULL
33227 };
33228
33229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33231 if (SWIG_arg_fail(1)) SWIG_fail;
33232 {
33233 arg2 = (int)(SWIG_As_int(obj1));
33234 if (SWIG_arg_fail(2)) SWIG_fail;
33235 }
33236 {
33237 arg3 = (bool)(SWIG_As_bool(obj2));
33238 if (SWIG_arg_fail(3)) SWIG_fail;
33239 }
33240 {
33241 PyThreadState* __tstate = wxPyBeginAllowThreads();
33242 (arg1)->Enable(arg2,arg3);
33243
33244 wxPyEndAllowThreads(__tstate);
33245 if (PyErr_Occurred()) SWIG_fail;
33246 }
33247 Py_INCREF(Py_None); resultobj = Py_None;
33248 return resultobj;
33249 fail:
33250 return NULL;
33251 }
33252
33253
33254 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33255 PyObject *resultobj;
33256 wxMenu *arg1 = (wxMenu *) 0 ;
33257 int arg2 ;
33258 bool result;
33259 PyObject * obj0 = 0 ;
33260 PyObject * obj1 = 0 ;
33261 char *kwnames[] = {
33262 (char *) "self",(char *) "id", NULL
33263 };
33264
33265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33267 if (SWIG_arg_fail(1)) SWIG_fail;
33268 {
33269 arg2 = (int)(SWIG_As_int(obj1));
33270 if (SWIG_arg_fail(2)) SWIG_fail;
33271 }
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33275
33276 wxPyEndAllowThreads(__tstate);
33277 if (PyErr_Occurred()) SWIG_fail;
33278 }
33279 {
33280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33281 }
33282 return resultobj;
33283 fail:
33284 return NULL;
33285 }
33286
33287
33288 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33289 PyObject *resultobj;
33290 wxMenu *arg1 = (wxMenu *) 0 ;
33291 int arg2 ;
33292 bool arg3 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 PyObject * obj2 = 0 ;
33296 char *kwnames[] = {
33297 (char *) "self",(char *) "id",(char *) "check", NULL
33298 };
33299
33300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33302 if (SWIG_arg_fail(1)) SWIG_fail;
33303 {
33304 arg2 = (int)(SWIG_As_int(obj1));
33305 if (SWIG_arg_fail(2)) SWIG_fail;
33306 }
33307 {
33308 arg3 = (bool)(SWIG_As_bool(obj2));
33309 if (SWIG_arg_fail(3)) SWIG_fail;
33310 }
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 (arg1)->Check(arg2,arg3);
33314
33315 wxPyEndAllowThreads(__tstate);
33316 if (PyErr_Occurred()) SWIG_fail;
33317 }
33318 Py_INCREF(Py_None); resultobj = Py_None;
33319 return resultobj;
33320 fail:
33321 return NULL;
33322 }
33323
33324
33325 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj;
33327 wxMenu *arg1 = (wxMenu *) 0 ;
33328 int arg2 ;
33329 bool result;
33330 PyObject * obj0 = 0 ;
33331 PyObject * obj1 = 0 ;
33332 char *kwnames[] = {
33333 (char *) "self",(char *) "id", NULL
33334 };
33335
33336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33338 if (SWIG_arg_fail(1)) SWIG_fail;
33339 {
33340 arg2 = (int)(SWIG_As_int(obj1));
33341 if (SWIG_arg_fail(2)) SWIG_fail;
33342 }
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33346
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 {
33351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33352 }
33353 return resultobj;
33354 fail:
33355 return NULL;
33356 }
33357
33358
33359 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33360 PyObject *resultobj;
33361 wxMenu *arg1 = (wxMenu *) 0 ;
33362 int arg2 ;
33363 wxString *arg3 = 0 ;
33364 bool temp3 = false ;
33365 PyObject * obj0 = 0 ;
33366 PyObject * obj1 = 0 ;
33367 PyObject * obj2 = 0 ;
33368 char *kwnames[] = {
33369 (char *) "self",(char *) "id",(char *) "label", NULL
33370 };
33371
33372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33374 if (SWIG_arg_fail(1)) SWIG_fail;
33375 {
33376 arg2 = (int)(SWIG_As_int(obj1));
33377 if (SWIG_arg_fail(2)) SWIG_fail;
33378 }
33379 {
33380 arg3 = wxString_in_helper(obj2);
33381 if (arg3 == NULL) SWIG_fail;
33382 temp3 = true;
33383 }
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33387
33388 wxPyEndAllowThreads(__tstate);
33389 if (PyErr_Occurred()) SWIG_fail;
33390 }
33391 Py_INCREF(Py_None); resultobj = Py_None;
33392 {
33393 if (temp3)
33394 delete arg3;
33395 }
33396 return resultobj;
33397 fail:
33398 {
33399 if (temp3)
33400 delete arg3;
33401 }
33402 return NULL;
33403 }
33404
33405
33406 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33407 PyObject *resultobj;
33408 wxMenu *arg1 = (wxMenu *) 0 ;
33409 int arg2 ;
33410 wxString result;
33411 PyObject * obj0 = 0 ;
33412 PyObject * obj1 = 0 ;
33413 char *kwnames[] = {
33414 (char *) "self",(char *) "id", NULL
33415 };
33416
33417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33419 if (SWIG_arg_fail(1)) SWIG_fail;
33420 {
33421 arg2 = (int)(SWIG_As_int(obj1));
33422 if (SWIG_arg_fail(2)) SWIG_fail;
33423 }
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33427
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 #if wxUSE_UNICODE
33433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33434 #else
33435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33436 #endif
33437 }
33438 return resultobj;
33439 fail:
33440 return NULL;
33441 }
33442
33443
33444 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33445 PyObject *resultobj;
33446 wxMenu *arg1 = (wxMenu *) 0 ;
33447 int arg2 ;
33448 wxString *arg3 = 0 ;
33449 bool temp3 = false ;
33450 PyObject * obj0 = 0 ;
33451 PyObject * obj1 = 0 ;
33452 PyObject * obj2 = 0 ;
33453 char *kwnames[] = {
33454 (char *) "self",(char *) "id",(char *) "helpString", NULL
33455 };
33456
33457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33459 if (SWIG_arg_fail(1)) SWIG_fail;
33460 {
33461 arg2 = (int)(SWIG_As_int(obj1));
33462 if (SWIG_arg_fail(2)) SWIG_fail;
33463 }
33464 {
33465 arg3 = wxString_in_helper(obj2);
33466 if (arg3 == NULL) SWIG_fail;
33467 temp3 = true;
33468 }
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33472
33473 wxPyEndAllowThreads(__tstate);
33474 if (PyErr_Occurred()) SWIG_fail;
33475 }
33476 Py_INCREF(Py_None); resultobj = Py_None;
33477 {
33478 if (temp3)
33479 delete arg3;
33480 }
33481 return resultobj;
33482 fail:
33483 {
33484 if (temp3)
33485 delete arg3;
33486 }
33487 return NULL;
33488 }
33489
33490
33491 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33492 PyObject *resultobj;
33493 wxMenu *arg1 = (wxMenu *) 0 ;
33494 int arg2 ;
33495 wxString result;
33496 PyObject * obj0 = 0 ;
33497 PyObject * obj1 = 0 ;
33498 char *kwnames[] = {
33499 (char *) "self",(char *) "id", NULL
33500 };
33501
33502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33504 if (SWIG_arg_fail(1)) SWIG_fail;
33505 {
33506 arg2 = (int)(SWIG_As_int(obj1));
33507 if (SWIG_arg_fail(2)) SWIG_fail;
33508 }
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33512
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 {
33517 #if wxUSE_UNICODE
33518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33519 #else
33520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33521 #endif
33522 }
33523 return resultobj;
33524 fail:
33525 return NULL;
33526 }
33527
33528
33529 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33530 PyObject *resultobj;
33531 wxMenu *arg1 = (wxMenu *) 0 ;
33532 wxString *arg2 = 0 ;
33533 bool temp2 = false ;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 char *kwnames[] = {
33537 (char *) "self",(char *) "title", NULL
33538 };
33539
33540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33542 if (SWIG_arg_fail(1)) SWIG_fail;
33543 {
33544 arg2 = wxString_in_helper(obj1);
33545 if (arg2 == NULL) SWIG_fail;
33546 temp2 = true;
33547 }
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 (arg1)->SetTitle((wxString const &)*arg2);
33551
33552 wxPyEndAllowThreads(__tstate);
33553 if (PyErr_Occurred()) SWIG_fail;
33554 }
33555 Py_INCREF(Py_None); resultobj = Py_None;
33556 {
33557 if (temp2)
33558 delete arg2;
33559 }
33560 return resultobj;
33561 fail:
33562 {
33563 if (temp2)
33564 delete arg2;
33565 }
33566 return NULL;
33567 }
33568
33569
33570 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33571 PyObject *resultobj;
33572 wxMenu *arg1 = (wxMenu *) 0 ;
33573 wxString result;
33574 PyObject * obj0 = 0 ;
33575 char *kwnames[] = {
33576 (char *) "self", NULL
33577 };
33578
33579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33581 if (SWIG_arg_fail(1)) SWIG_fail;
33582 {
33583 PyThreadState* __tstate = wxPyBeginAllowThreads();
33584 result = ((wxMenu const *)arg1)->GetTitle();
33585
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 {
33590 #if wxUSE_UNICODE
33591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33592 #else
33593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33594 #endif
33595 }
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33603 PyObject *resultobj;
33604 wxMenu *arg1 = (wxMenu *) 0 ;
33605 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33606 PyObject * obj0 = 0 ;
33607 PyObject * obj1 = 0 ;
33608 char *kwnames[] = {
33609 (char *) "self",(char *) "handler", NULL
33610 };
33611
33612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33614 if (SWIG_arg_fail(1)) SWIG_fail;
33615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33616 if (SWIG_arg_fail(2)) SWIG_fail;
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 (arg1)->SetEventHandler(arg2);
33620
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 Py_INCREF(Py_None); resultobj = Py_None;
33625 return resultobj;
33626 fail:
33627 return NULL;
33628 }
33629
33630
33631 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33632 PyObject *resultobj;
33633 wxMenu *arg1 = (wxMenu *) 0 ;
33634 wxEvtHandler *result;
33635 PyObject * obj0 = 0 ;
33636 char *kwnames[] = {
33637 (char *) "self", NULL
33638 };
33639
33640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33642 if (SWIG_arg_fail(1)) SWIG_fail;
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33646
33647 wxPyEndAllowThreads(__tstate);
33648 if (PyErr_Occurred()) SWIG_fail;
33649 }
33650 {
33651 resultobj = wxPyMake_wxObject(result, 0);
33652 }
33653 return resultobj;
33654 fail:
33655 return NULL;
33656 }
33657
33658
33659 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33660 PyObject *resultobj;
33661 wxMenu *arg1 = (wxMenu *) 0 ;
33662 wxWindow *arg2 = (wxWindow *) 0 ;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 char *kwnames[] = {
33666 (char *) "self",(char *) "win", NULL
33667 };
33668
33669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33671 if (SWIG_arg_fail(1)) SWIG_fail;
33672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33673 if (SWIG_arg_fail(2)) SWIG_fail;
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 (arg1)->SetInvokingWindow(arg2);
33677
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 Py_INCREF(Py_None); resultobj = Py_None;
33682 return resultobj;
33683 fail:
33684 return NULL;
33685 }
33686
33687
33688 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33689 PyObject *resultobj;
33690 wxMenu *arg1 = (wxMenu *) 0 ;
33691 wxWindow *result;
33692 PyObject * obj0 = 0 ;
33693 char *kwnames[] = {
33694 (char *) "self", NULL
33695 };
33696
33697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33699 if (SWIG_arg_fail(1)) SWIG_fail;
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33703
33704 wxPyEndAllowThreads(__tstate);
33705 if (PyErr_Occurred()) SWIG_fail;
33706 }
33707 {
33708 resultobj = wxPyMake_wxObject(result, 0);
33709 }
33710 return resultobj;
33711 fail:
33712 return NULL;
33713 }
33714
33715
33716 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33717 PyObject *resultobj;
33718 wxMenu *arg1 = (wxMenu *) 0 ;
33719 long result;
33720 PyObject * obj0 = 0 ;
33721 char *kwnames[] = {
33722 (char *) "self", NULL
33723 };
33724
33725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33727 if (SWIG_arg_fail(1)) SWIG_fail;
33728 {
33729 PyThreadState* __tstate = wxPyBeginAllowThreads();
33730 result = (long)((wxMenu const *)arg1)->GetStyle();
33731
33732 wxPyEndAllowThreads(__tstate);
33733 if (PyErr_Occurred()) SWIG_fail;
33734 }
33735 {
33736 resultobj = SWIG_From_long((long)(result));
33737 }
33738 return resultobj;
33739 fail:
33740 return NULL;
33741 }
33742
33743
33744 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33745 PyObject *resultobj;
33746 wxMenu *arg1 = (wxMenu *) 0 ;
33747 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33748 PyObject * obj0 = 0 ;
33749 PyObject * obj1 = 0 ;
33750 char *kwnames[] = {
33751 (char *) "self",(char *) "source", NULL
33752 };
33753
33754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33756 if (SWIG_arg_fail(1)) SWIG_fail;
33757 if (obj1) {
33758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33759 if (SWIG_arg_fail(2)) SWIG_fail;
33760 }
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 (arg1)->UpdateUI(arg2);
33764
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 Py_INCREF(Py_None); resultobj = Py_None;
33769 return resultobj;
33770 fail:
33771 return NULL;
33772 }
33773
33774
33775 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj;
33777 wxMenu *arg1 = (wxMenu *) 0 ;
33778 wxMenuBar *result;
33779 PyObject * obj0 = 0 ;
33780 char *kwnames[] = {
33781 (char *) "self", NULL
33782 };
33783
33784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33786 if (SWIG_arg_fail(1)) SWIG_fail;
33787 {
33788 PyThreadState* __tstate = wxPyBeginAllowThreads();
33789 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33790
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 {
33795 resultobj = wxPyMake_wxObject(result, 0);
33796 }
33797 return resultobj;
33798 fail:
33799 return NULL;
33800 }
33801
33802
33803 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33804 PyObject *resultobj;
33805 wxMenu *arg1 = (wxMenu *) 0 ;
33806 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33807 PyObject * obj0 = 0 ;
33808 PyObject * obj1 = 0 ;
33809 char *kwnames[] = {
33810 (char *) "self",(char *) "menubar", NULL
33811 };
33812
33813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33815 if (SWIG_arg_fail(1)) SWIG_fail;
33816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33817 if (SWIG_arg_fail(2)) SWIG_fail;
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 (arg1)->Attach(arg2);
33821
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 Py_INCREF(Py_None); resultobj = Py_None;
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj;
33834 wxMenu *arg1 = (wxMenu *) 0 ;
33835 PyObject * obj0 = 0 ;
33836 char *kwnames[] = {
33837 (char *) "self", NULL
33838 };
33839
33840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33842 if (SWIG_arg_fail(1)) SWIG_fail;
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 (arg1)->Detach();
33846
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 Py_INCREF(Py_None); resultobj = Py_None;
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj;
33859 wxMenu *arg1 = (wxMenu *) 0 ;
33860 bool result;
33861 PyObject * obj0 = 0 ;
33862 char *kwnames[] = {
33863 (char *) "self", NULL
33864 };
33865
33866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33868 if (SWIG_arg_fail(1)) SWIG_fail;
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 result = (bool)((wxMenu const *)arg1)->IsAttached();
33872
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 {
33877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33878 }
33879 return resultobj;
33880 fail:
33881 return NULL;
33882 }
33883
33884
33885 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33886 PyObject *resultobj;
33887 wxMenu *arg1 = (wxMenu *) 0 ;
33888 wxMenu *arg2 = (wxMenu *) 0 ;
33889 PyObject * obj0 = 0 ;
33890 PyObject * obj1 = 0 ;
33891 char *kwnames[] = {
33892 (char *) "self",(char *) "parent", NULL
33893 };
33894
33895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
33896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(1)) SWIG_fail;
33898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33899 if (SWIG_arg_fail(2)) SWIG_fail;
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 (arg1)->SetParent(arg2);
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 Py_INCREF(Py_None); resultobj = Py_None;
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 wxMenu *result;
33918 PyObject * obj0 = 0 ;
33919 char *kwnames[] = {
33920 (char *) "self", NULL
33921 };
33922
33923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
33924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33925 if (SWIG_arg_fail(1)) SWIG_fail;
33926 {
33927 PyThreadState* __tstate = wxPyBeginAllowThreads();
33928 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
33929
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 {
33934 resultobj = wxPyMake_wxObject(result, 0);
33935 }
33936 return resultobj;
33937 fail:
33938 return NULL;
33939 }
33940
33941
33942 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
33943 PyObject *obj;
33944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33945 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
33946 Py_INCREF(obj);
33947 return Py_BuildValue((char *)"");
33948 }
33949 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj;
33951 long arg1 = (long) 0 ;
33952 wxMenuBar *result;
33953 PyObject * obj0 = 0 ;
33954 char *kwnames[] = {
33955 (char *) "style", NULL
33956 };
33957
33958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
33959 if (obj0) {
33960 {
33961 arg1 = (long)(SWIG_As_long(obj0));
33962 if (SWIG_arg_fail(1)) SWIG_fail;
33963 }
33964 }
33965 {
33966 if (!wxPyCheckForApp()) SWIG_fail;
33967 PyThreadState* __tstate = wxPyBeginAllowThreads();
33968 result = (wxMenuBar *)new wxMenuBar(arg1);
33969
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj;
33982 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
33983 wxMenu *arg2 = (wxMenu *) 0 ;
33984 wxString *arg3 = 0 ;
33985 bool result;
33986 bool temp3 = false ;
33987 PyObject * obj0 = 0 ;
33988 PyObject * obj1 = 0 ;
33989 PyObject * obj2 = 0 ;
33990 char *kwnames[] = {
33991 (char *) "self",(char *) "menu",(char *) "title", NULL
33992 };
33993
33994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
33995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
33996 if (SWIG_arg_fail(1)) SWIG_fail;
33997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33998 if (SWIG_arg_fail(2)) SWIG_fail;
33999 {
34000 arg3 = wxString_in_helper(obj2);
34001 if (arg3 == NULL) SWIG_fail;
34002 temp3 = true;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34007
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 {
34012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34013 }
34014 {
34015 if (temp3)
34016 delete arg3;
34017 }
34018 return resultobj;
34019 fail:
34020 {
34021 if (temp3)
34022 delete arg3;
34023 }
34024 return NULL;
34025 }
34026
34027
34028 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj;
34030 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34031 size_t arg2 ;
34032 wxMenu *arg3 = (wxMenu *) 0 ;
34033 wxString *arg4 = 0 ;
34034 bool result;
34035 bool temp4 = false ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 PyObject * obj2 = 0 ;
34039 PyObject * obj3 = 0 ;
34040 char *kwnames[] = {
34041 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34042 };
34043
34044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34046 if (SWIG_arg_fail(1)) SWIG_fail;
34047 {
34048 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34049 if (SWIG_arg_fail(2)) SWIG_fail;
34050 }
34051 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34052 if (SWIG_arg_fail(3)) SWIG_fail;
34053 {
34054 arg4 = wxString_in_helper(obj3);
34055 if (arg4 == NULL) SWIG_fail;
34056 temp4 = true;
34057 }
34058 {
34059 PyThreadState* __tstate = wxPyBeginAllowThreads();
34060 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34061
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 {
34066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34067 }
34068 {
34069 if (temp4)
34070 delete arg4;
34071 }
34072 return resultobj;
34073 fail:
34074 {
34075 if (temp4)
34076 delete arg4;
34077 }
34078 return NULL;
34079 }
34080
34081
34082 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34083 PyObject *resultobj;
34084 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34085 size_t result;
34086 PyObject * obj0 = 0 ;
34087 char *kwnames[] = {
34088 (char *) "self", NULL
34089 };
34090
34091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34093 if (SWIG_arg_fail(1)) SWIG_fail;
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34097
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 {
34102 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj;
34112 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34113 size_t arg2 ;
34114 wxMenu *result;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char *kwnames[] = {
34118 (char *) "self",(char *) "pos", NULL
34119 };
34120
34121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34123 if (SWIG_arg_fail(1)) SWIG_fail;
34124 {
34125 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34126 if (SWIG_arg_fail(2)) SWIG_fail;
34127 }
34128 {
34129 PyThreadState* __tstate = wxPyBeginAllowThreads();
34130 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34131
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 {
34136 resultobj = wxPyMake_wxObject(result, 0);
34137 }
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj;
34146 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34147 size_t arg2 ;
34148 wxMenu *arg3 = (wxMenu *) 0 ;
34149 wxString *arg4 = 0 ;
34150 wxMenu *result;
34151 bool temp4 = false ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 PyObject * obj2 = 0 ;
34155 PyObject * obj3 = 0 ;
34156 char *kwnames[] = {
34157 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34158 };
34159
34160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34162 if (SWIG_arg_fail(1)) SWIG_fail;
34163 {
34164 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34165 if (SWIG_arg_fail(2)) SWIG_fail;
34166 }
34167 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34168 if (SWIG_arg_fail(3)) SWIG_fail;
34169 {
34170 arg4 = wxString_in_helper(obj3);
34171 if (arg4 == NULL) SWIG_fail;
34172 temp4 = true;
34173 }
34174 {
34175 PyThreadState* __tstate = wxPyBeginAllowThreads();
34176 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34177
34178 wxPyEndAllowThreads(__tstate);
34179 if (PyErr_Occurred()) SWIG_fail;
34180 }
34181 {
34182 resultobj = wxPyMake_wxObject(result, 0);
34183 }
34184 {
34185 if (temp4)
34186 delete arg4;
34187 }
34188 return resultobj;
34189 fail:
34190 {
34191 if (temp4)
34192 delete arg4;
34193 }
34194 return NULL;
34195 }
34196
34197
34198 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34199 PyObject *resultobj;
34200 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34201 size_t arg2 ;
34202 wxMenu *result;
34203 PyObject * obj0 = 0 ;
34204 PyObject * obj1 = 0 ;
34205 char *kwnames[] = {
34206 (char *) "self",(char *) "pos", NULL
34207 };
34208
34209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34211 if (SWIG_arg_fail(1)) SWIG_fail;
34212 {
34213 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34214 if (SWIG_arg_fail(2)) SWIG_fail;
34215 }
34216 {
34217 PyThreadState* __tstate = wxPyBeginAllowThreads();
34218 result = (wxMenu *)(arg1)->Remove(arg2);
34219
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 {
34224 resultobj = wxPyMake_wxObject(result, 0);
34225 }
34226 return resultobj;
34227 fail:
34228 return NULL;
34229 }
34230
34231
34232 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34233 PyObject *resultobj;
34234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34235 size_t arg2 ;
34236 bool arg3 ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 PyObject * obj2 = 0 ;
34240 char *kwnames[] = {
34241 (char *) "self",(char *) "pos",(char *) "enable", NULL
34242 };
34243
34244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34246 if (SWIG_arg_fail(1)) SWIG_fail;
34247 {
34248 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34249 if (SWIG_arg_fail(2)) SWIG_fail;
34250 }
34251 {
34252 arg3 = (bool)(SWIG_As_bool(obj2));
34253 if (SWIG_arg_fail(3)) SWIG_fail;
34254 }
34255 {
34256 PyThreadState* __tstate = wxPyBeginAllowThreads();
34257 (arg1)->EnableTop(arg2,arg3);
34258
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 Py_INCREF(Py_None); resultobj = Py_None;
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj;
34271 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34272 size_t arg2 ;
34273 bool result;
34274 PyObject * obj0 = 0 ;
34275 PyObject * obj1 = 0 ;
34276 char *kwnames[] = {
34277 (char *) "self",(char *) "pos", NULL
34278 };
34279
34280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34282 if (SWIG_arg_fail(1)) SWIG_fail;
34283 {
34284 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34285 if (SWIG_arg_fail(2)) SWIG_fail;
34286 }
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34290
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 {
34295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34296 }
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34304 PyObject *resultobj;
34305 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34306 size_t arg2 ;
34307 wxString *arg3 = 0 ;
34308 bool temp3 = false ;
34309 PyObject * obj0 = 0 ;
34310 PyObject * obj1 = 0 ;
34311 PyObject * obj2 = 0 ;
34312 char *kwnames[] = {
34313 (char *) "self",(char *) "pos",(char *) "label", NULL
34314 };
34315
34316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34318 if (SWIG_arg_fail(1)) SWIG_fail;
34319 {
34320 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34321 if (SWIG_arg_fail(2)) SWIG_fail;
34322 }
34323 {
34324 arg3 = wxString_in_helper(obj2);
34325 if (arg3 == NULL) SWIG_fail;
34326 temp3 = true;
34327 }
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34331
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 Py_INCREF(Py_None); resultobj = Py_None;
34336 {
34337 if (temp3)
34338 delete arg3;
34339 }
34340 return resultobj;
34341 fail:
34342 {
34343 if (temp3)
34344 delete arg3;
34345 }
34346 return NULL;
34347 }
34348
34349
34350 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34351 PyObject *resultobj;
34352 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34353 size_t arg2 ;
34354 wxString result;
34355 PyObject * obj0 = 0 ;
34356 PyObject * obj1 = 0 ;
34357 char *kwnames[] = {
34358 (char *) "self",(char *) "pos", NULL
34359 };
34360
34361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34363 if (SWIG_arg_fail(1)) SWIG_fail;
34364 {
34365 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34366 if (SWIG_arg_fail(2)) SWIG_fail;
34367 }
34368 {
34369 PyThreadState* __tstate = wxPyBeginAllowThreads();
34370 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34371
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 {
34376 #if wxUSE_UNICODE
34377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34378 #else
34379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34380 #endif
34381 }
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34389 PyObject *resultobj;
34390 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34391 wxString *arg2 = 0 ;
34392 wxString *arg3 = 0 ;
34393 int result;
34394 bool temp2 = false ;
34395 bool temp3 = false ;
34396 PyObject * obj0 = 0 ;
34397 PyObject * obj1 = 0 ;
34398 PyObject * obj2 = 0 ;
34399 char *kwnames[] = {
34400 (char *) "self",(char *) "menu",(char *) "item", NULL
34401 };
34402
34403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34405 if (SWIG_arg_fail(1)) SWIG_fail;
34406 {
34407 arg2 = wxString_in_helper(obj1);
34408 if (arg2 == NULL) SWIG_fail;
34409 temp2 = true;
34410 }
34411 {
34412 arg3 = wxString_in_helper(obj2);
34413 if (arg3 == NULL) SWIG_fail;
34414 temp3 = true;
34415 }
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34419
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 {
34424 resultobj = SWIG_From_int((int)(result));
34425 }
34426 {
34427 if (temp2)
34428 delete arg2;
34429 }
34430 {
34431 if (temp3)
34432 delete arg3;
34433 }
34434 return resultobj;
34435 fail:
34436 {
34437 if (temp2)
34438 delete arg2;
34439 }
34440 {
34441 if (temp3)
34442 delete arg3;
34443 }
34444 return NULL;
34445 }
34446
34447
34448 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34449 PyObject *resultobj;
34450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34451 int arg2 ;
34452 wxMenuItem *result;
34453 PyObject * obj0 = 0 ;
34454 PyObject * obj1 = 0 ;
34455 char *kwnames[] = {
34456 (char *) "self",(char *) "id", NULL
34457 };
34458
34459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34461 if (SWIG_arg_fail(1)) SWIG_fail;
34462 {
34463 arg2 = (int)(SWIG_As_int(obj1));
34464 if (SWIG_arg_fail(2)) SWIG_fail;
34465 }
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34469
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 {
34474 resultobj = wxPyMake_wxObject(result, 0);
34475 }
34476 return resultobj;
34477 fail:
34478 return NULL;
34479 }
34480
34481
34482 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34483 PyObject *resultobj;
34484 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34485 wxString *arg2 = 0 ;
34486 int result;
34487 bool temp2 = false ;
34488 PyObject * obj0 = 0 ;
34489 PyObject * obj1 = 0 ;
34490 char *kwnames[] = {
34491 (char *) "self",(char *) "title", NULL
34492 };
34493
34494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34496 if (SWIG_arg_fail(1)) SWIG_fail;
34497 {
34498 arg2 = wxString_in_helper(obj1);
34499 if (arg2 == NULL) SWIG_fail;
34500 temp2 = true;
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34505
34506 wxPyEndAllowThreads(__tstate);
34507 if (PyErr_Occurred()) SWIG_fail;
34508 }
34509 {
34510 resultobj = SWIG_From_int((int)(result));
34511 }
34512 {
34513 if (temp2)
34514 delete arg2;
34515 }
34516 return resultobj;
34517 fail:
34518 {
34519 if (temp2)
34520 delete arg2;
34521 }
34522 return NULL;
34523 }
34524
34525
34526 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj;
34528 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34529 int arg2 ;
34530 bool arg3 ;
34531 PyObject * obj0 = 0 ;
34532 PyObject * obj1 = 0 ;
34533 PyObject * obj2 = 0 ;
34534 char *kwnames[] = {
34535 (char *) "self",(char *) "id",(char *) "enable", NULL
34536 };
34537
34538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34540 if (SWIG_arg_fail(1)) SWIG_fail;
34541 {
34542 arg2 = (int)(SWIG_As_int(obj1));
34543 if (SWIG_arg_fail(2)) SWIG_fail;
34544 }
34545 {
34546 arg3 = (bool)(SWIG_As_bool(obj2));
34547 if (SWIG_arg_fail(3)) SWIG_fail;
34548 }
34549 {
34550 PyThreadState* __tstate = wxPyBeginAllowThreads();
34551 (arg1)->Enable(arg2,arg3);
34552
34553 wxPyEndAllowThreads(__tstate);
34554 if (PyErr_Occurred()) SWIG_fail;
34555 }
34556 Py_INCREF(Py_None); resultobj = Py_None;
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34564 PyObject *resultobj;
34565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34566 int arg2 ;
34567 bool arg3 ;
34568 PyObject * obj0 = 0 ;
34569 PyObject * obj1 = 0 ;
34570 PyObject * obj2 = 0 ;
34571 char *kwnames[] = {
34572 (char *) "self",(char *) "id",(char *) "check", NULL
34573 };
34574
34575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34577 if (SWIG_arg_fail(1)) SWIG_fail;
34578 {
34579 arg2 = (int)(SWIG_As_int(obj1));
34580 if (SWIG_arg_fail(2)) SWIG_fail;
34581 }
34582 {
34583 arg3 = (bool)(SWIG_As_bool(obj2));
34584 if (SWIG_arg_fail(3)) SWIG_fail;
34585 }
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 (arg1)->Check(arg2,arg3);
34589
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 Py_INCREF(Py_None); resultobj = Py_None;
34594 return resultobj;
34595 fail:
34596 return NULL;
34597 }
34598
34599
34600 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34601 PyObject *resultobj;
34602 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34603 int arg2 ;
34604 bool result;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char *kwnames[] = {
34608 (char *) "self",(char *) "id", NULL
34609 };
34610
34611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34613 if (SWIG_arg_fail(1)) SWIG_fail;
34614 {
34615 arg2 = (int)(SWIG_As_int(obj1));
34616 if (SWIG_arg_fail(2)) SWIG_fail;
34617 }
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34621
34622 wxPyEndAllowThreads(__tstate);
34623 if (PyErr_Occurred()) SWIG_fail;
34624 }
34625 {
34626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34627 }
34628 return resultobj;
34629 fail:
34630 return NULL;
34631 }
34632
34633
34634 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34635 PyObject *resultobj;
34636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34637 int arg2 ;
34638 bool result;
34639 PyObject * obj0 = 0 ;
34640 PyObject * obj1 = 0 ;
34641 char *kwnames[] = {
34642 (char *) "self",(char *) "id", NULL
34643 };
34644
34645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34647 if (SWIG_arg_fail(1)) SWIG_fail;
34648 {
34649 arg2 = (int)(SWIG_As_int(obj1));
34650 if (SWIG_arg_fail(2)) SWIG_fail;
34651 }
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34655
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 {
34660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34661 }
34662 return resultobj;
34663 fail:
34664 return NULL;
34665 }
34666
34667
34668 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34669 PyObject *resultobj;
34670 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34671 int arg2 ;
34672 wxString *arg3 = 0 ;
34673 bool temp3 = false ;
34674 PyObject * obj0 = 0 ;
34675 PyObject * obj1 = 0 ;
34676 PyObject * obj2 = 0 ;
34677 char *kwnames[] = {
34678 (char *) "self",(char *) "id",(char *) "label", NULL
34679 };
34680
34681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34683 if (SWIG_arg_fail(1)) SWIG_fail;
34684 {
34685 arg2 = (int)(SWIG_As_int(obj1));
34686 if (SWIG_arg_fail(2)) SWIG_fail;
34687 }
34688 {
34689 arg3 = wxString_in_helper(obj2);
34690 if (arg3 == NULL) SWIG_fail;
34691 temp3 = true;
34692 }
34693 {
34694 PyThreadState* __tstate = wxPyBeginAllowThreads();
34695 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34696
34697 wxPyEndAllowThreads(__tstate);
34698 if (PyErr_Occurred()) SWIG_fail;
34699 }
34700 Py_INCREF(Py_None); resultobj = Py_None;
34701 {
34702 if (temp3)
34703 delete arg3;
34704 }
34705 return resultobj;
34706 fail:
34707 {
34708 if (temp3)
34709 delete arg3;
34710 }
34711 return NULL;
34712 }
34713
34714
34715 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34716 PyObject *resultobj;
34717 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34718 int arg2 ;
34719 wxString result;
34720 PyObject * obj0 = 0 ;
34721 PyObject * obj1 = 0 ;
34722 char *kwnames[] = {
34723 (char *) "self",(char *) "id", NULL
34724 };
34725
34726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34728 if (SWIG_arg_fail(1)) SWIG_fail;
34729 {
34730 arg2 = (int)(SWIG_As_int(obj1));
34731 if (SWIG_arg_fail(2)) SWIG_fail;
34732 }
34733 {
34734 PyThreadState* __tstate = wxPyBeginAllowThreads();
34735 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34736
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 {
34741 #if wxUSE_UNICODE
34742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34743 #else
34744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34745 #endif
34746 }
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34754 PyObject *resultobj;
34755 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34756 int arg2 ;
34757 wxString *arg3 = 0 ;
34758 bool temp3 = false ;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 PyObject * obj2 = 0 ;
34762 char *kwnames[] = {
34763 (char *) "self",(char *) "id",(char *) "helpString", NULL
34764 };
34765
34766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34768 if (SWIG_arg_fail(1)) SWIG_fail;
34769 {
34770 arg2 = (int)(SWIG_As_int(obj1));
34771 if (SWIG_arg_fail(2)) SWIG_fail;
34772 }
34773 {
34774 arg3 = wxString_in_helper(obj2);
34775 if (arg3 == NULL) SWIG_fail;
34776 temp3 = true;
34777 }
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34781
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 Py_INCREF(Py_None); resultobj = Py_None;
34786 {
34787 if (temp3)
34788 delete arg3;
34789 }
34790 return resultobj;
34791 fail:
34792 {
34793 if (temp3)
34794 delete arg3;
34795 }
34796 return NULL;
34797 }
34798
34799
34800 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34801 PyObject *resultobj;
34802 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34803 int arg2 ;
34804 wxString result;
34805 PyObject * obj0 = 0 ;
34806 PyObject * obj1 = 0 ;
34807 char *kwnames[] = {
34808 (char *) "self",(char *) "id", NULL
34809 };
34810
34811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34813 if (SWIG_arg_fail(1)) SWIG_fail;
34814 {
34815 arg2 = (int)(SWIG_As_int(obj1));
34816 if (SWIG_arg_fail(2)) SWIG_fail;
34817 }
34818 {
34819 PyThreadState* __tstate = wxPyBeginAllowThreads();
34820 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34821
34822 wxPyEndAllowThreads(__tstate);
34823 if (PyErr_Occurred()) SWIG_fail;
34824 }
34825 {
34826 #if wxUSE_UNICODE
34827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34828 #else
34829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34830 #endif
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj;
34840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34841 wxFrame *result;
34842 PyObject * obj0 = 0 ;
34843 char *kwnames[] = {
34844 (char *) "self", NULL
34845 };
34846
34847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34849 if (SWIG_arg_fail(1)) SWIG_fail;
34850 {
34851 PyThreadState* __tstate = wxPyBeginAllowThreads();
34852 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34853
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 {
34858 resultobj = wxPyMake_wxObject(result, 0);
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34867 PyObject *resultobj;
34868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34869 bool result;
34870 PyObject * obj0 = 0 ;
34871 char *kwnames[] = {
34872 (char *) "self", NULL
34873 };
34874
34875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34877 if (SWIG_arg_fail(1)) SWIG_fail;
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34881
34882 wxPyEndAllowThreads(__tstate);
34883 if (PyErr_Occurred()) SWIG_fail;
34884 }
34885 {
34886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34887 }
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34895 PyObject *resultobj;
34896 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34897 wxFrame *arg2 = (wxFrame *) 0 ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 char *kwnames[] = {
34901 (char *) "self",(char *) "frame", NULL
34902 };
34903
34904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
34905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34906 if (SWIG_arg_fail(1)) SWIG_fail;
34907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
34908 if (SWIG_arg_fail(2)) SWIG_fail;
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 (arg1)->Attach(arg2);
34912
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 Py_INCREF(Py_None); resultobj = Py_None;
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj;
34925 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34926 PyObject * obj0 = 0 ;
34927 char *kwnames[] = {
34928 (char *) "self", NULL
34929 };
34930
34931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
34932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34933 if (SWIG_arg_fail(1)) SWIG_fail;
34934 {
34935 PyThreadState* __tstate = wxPyBeginAllowThreads();
34936 (arg1)->Detach();
34937
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 Py_INCREF(Py_None); resultobj = Py_None;
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
34949 PyObject *obj;
34950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34951 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
34952 Py_INCREF(obj);
34953 return Py_BuildValue((char *)"");
34954 }
34955 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34956 PyObject *resultobj;
34957 wxMenu *arg1 = (wxMenu *) NULL ;
34958 int arg2 = (int) wxID_ANY ;
34959 wxString const &arg3_defvalue = wxPyEmptyString ;
34960 wxString *arg3 = (wxString *) &arg3_defvalue ;
34961 wxString const &arg4_defvalue = wxPyEmptyString ;
34962 wxString *arg4 = (wxString *) &arg4_defvalue ;
34963 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34964 wxMenu *arg6 = (wxMenu *) NULL ;
34965 wxMenuItem *result;
34966 bool temp3 = false ;
34967 bool temp4 = false ;
34968 PyObject * obj0 = 0 ;
34969 PyObject * obj1 = 0 ;
34970 PyObject * obj2 = 0 ;
34971 PyObject * obj3 = 0 ;
34972 PyObject * obj4 = 0 ;
34973 PyObject * obj5 = 0 ;
34974 char *kwnames[] = {
34975 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
34976 };
34977
34978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34979 if (obj0) {
34980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34981 if (SWIG_arg_fail(1)) SWIG_fail;
34982 }
34983 if (obj1) {
34984 {
34985 arg2 = (int)(SWIG_As_int(obj1));
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 }
34988 }
34989 if (obj2) {
34990 {
34991 arg3 = wxString_in_helper(obj2);
34992 if (arg3 == NULL) SWIG_fail;
34993 temp3 = true;
34994 }
34995 }
34996 if (obj3) {
34997 {
34998 arg4 = wxString_in_helper(obj3);
34999 if (arg4 == NULL) SWIG_fail;
35000 temp4 = true;
35001 }
35002 }
35003 if (obj4) {
35004 {
35005 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35006 if (SWIG_arg_fail(5)) SWIG_fail;
35007 }
35008 }
35009 if (obj5) {
35010 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35011 if (SWIG_arg_fail(6)) SWIG_fail;
35012 }
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35016
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 {
35021 resultobj = wxPyMake_wxObject(result, 1);
35022 }
35023 {
35024 if (temp3)
35025 delete arg3;
35026 }
35027 {
35028 if (temp4)
35029 delete arg4;
35030 }
35031 return resultobj;
35032 fail:
35033 {
35034 if (temp3)
35035 delete arg3;
35036 }
35037 {
35038 if (temp4)
35039 delete arg4;
35040 }
35041 return NULL;
35042 }
35043
35044
35045 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35046 PyObject *resultobj;
35047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35048 wxMenu *result;
35049 PyObject * obj0 = 0 ;
35050 char *kwnames[] = {
35051 (char *) "self", NULL
35052 };
35053
35054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35056 if (SWIG_arg_fail(1)) SWIG_fail;
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35060
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 {
35065 resultobj = wxPyMake_wxObject(result, 0);
35066 }
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35074 PyObject *resultobj;
35075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35076 wxMenu *arg2 = (wxMenu *) 0 ;
35077 PyObject * obj0 = 0 ;
35078 PyObject * obj1 = 0 ;
35079 char *kwnames[] = {
35080 (char *) "self",(char *) "menu", NULL
35081 };
35082
35083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35085 if (SWIG_arg_fail(1)) SWIG_fail;
35086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35087 if (SWIG_arg_fail(2)) SWIG_fail;
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 (arg1)->SetMenu(arg2);
35091
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 Py_INCREF(Py_None); resultobj = Py_None;
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35103 PyObject *resultobj;
35104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35105 int arg2 ;
35106 PyObject * obj0 = 0 ;
35107 PyObject * obj1 = 0 ;
35108 char *kwnames[] = {
35109 (char *) "self",(char *) "id", NULL
35110 };
35111
35112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35114 if (SWIG_arg_fail(1)) SWIG_fail;
35115 {
35116 arg2 = (int)(SWIG_As_int(obj1));
35117 if (SWIG_arg_fail(2)) SWIG_fail;
35118 }
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 (arg1)->SetId(arg2);
35122
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 Py_INCREF(Py_None); resultobj = Py_None;
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35134 PyObject *resultobj;
35135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35136 int result;
35137 PyObject * obj0 = 0 ;
35138 char *kwnames[] = {
35139 (char *) "self", NULL
35140 };
35141
35142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35144 if (SWIG_arg_fail(1)) SWIG_fail;
35145 {
35146 PyThreadState* __tstate = wxPyBeginAllowThreads();
35147 result = (int)((wxMenuItem const *)arg1)->GetId();
35148
35149 wxPyEndAllowThreads(__tstate);
35150 if (PyErr_Occurred()) SWIG_fail;
35151 }
35152 {
35153 resultobj = SWIG_From_int((int)(result));
35154 }
35155 return resultobj;
35156 fail:
35157 return NULL;
35158 }
35159
35160
35161 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35162 PyObject *resultobj;
35163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35164 bool result;
35165 PyObject * obj0 = 0 ;
35166 char *kwnames[] = {
35167 (char *) "self", NULL
35168 };
35169
35170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35172 if (SWIG_arg_fail(1)) SWIG_fail;
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35176
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 {
35181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35182 }
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35190 PyObject *resultobj;
35191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35192 wxString *arg2 = 0 ;
35193 bool temp2 = false ;
35194 PyObject * obj0 = 0 ;
35195 PyObject * obj1 = 0 ;
35196 char *kwnames[] = {
35197 (char *) "self",(char *) "str", NULL
35198 };
35199
35200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35202 if (SWIG_arg_fail(1)) SWIG_fail;
35203 {
35204 arg2 = wxString_in_helper(obj1);
35205 if (arg2 == NULL) SWIG_fail;
35206 temp2 = true;
35207 }
35208 {
35209 PyThreadState* __tstate = wxPyBeginAllowThreads();
35210 (arg1)->SetText((wxString const &)*arg2);
35211
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 Py_INCREF(Py_None); resultobj = Py_None;
35216 {
35217 if (temp2)
35218 delete arg2;
35219 }
35220 return resultobj;
35221 fail:
35222 {
35223 if (temp2)
35224 delete arg2;
35225 }
35226 return NULL;
35227 }
35228
35229
35230 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35231 PyObject *resultobj;
35232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35233 wxString result;
35234 PyObject * obj0 = 0 ;
35235 char *kwnames[] = {
35236 (char *) "self", NULL
35237 };
35238
35239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35241 if (SWIG_arg_fail(1)) SWIG_fail;
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = ((wxMenuItem const *)arg1)->GetLabel();
35245
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 {
35250 #if wxUSE_UNICODE
35251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35252 #else
35253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35254 #endif
35255 }
35256 return resultobj;
35257 fail:
35258 return NULL;
35259 }
35260
35261
35262 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35263 PyObject *resultobj;
35264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35265 wxString *result;
35266 PyObject * obj0 = 0 ;
35267 char *kwnames[] = {
35268 (char *) "self", NULL
35269 };
35270
35271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35273 if (SWIG_arg_fail(1)) SWIG_fail;
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 {
35277 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35278 result = (wxString *) &_result_ref;
35279 }
35280
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 {
35285 #if wxUSE_UNICODE
35286 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35287 #else
35288 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35289 #endif
35290 }
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35298 PyObject *resultobj;
35299 wxString *arg1 = 0 ;
35300 wxString result;
35301 bool temp1 = false ;
35302 PyObject * obj0 = 0 ;
35303 char *kwnames[] = {
35304 (char *) "text", NULL
35305 };
35306
35307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35308 {
35309 arg1 = wxString_in_helper(obj0);
35310 if (arg1 == NULL) SWIG_fail;
35311 temp1 = true;
35312 }
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35316
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 {
35321 #if wxUSE_UNICODE
35322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35323 #else
35324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35325 #endif
35326 }
35327 {
35328 if (temp1)
35329 delete arg1;
35330 }
35331 return resultobj;
35332 fail:
35333 {
35334 if (temp1)
35335 delete arg1;
35336 }
35337 return NULL;
35338 }
35339
35340
35341 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35342 PyObject *resultobj;
35343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35344 wxItemKind result;
35345 PyObject * obj0 = 0 ;
35346 char *kwnames[] = {
35347 (char *) "self", NULL
35348 };
35349
35350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35352 if (SWIG_arg_fail(1)) SWIG_fail;
35353 {
35354 PyThreadState* __tstate = wxPyBeginAllowThreads();
35355 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35356
35357 wxPyEndAllowThreads(__tstate);
35358 if (PyErr_Occurred()) SWIG_fail;
35359 }
35360 resultobj = SWIG_From_int((result));
35361 return resultobj;
35362 fail:
35363 return NULL;
35364 }
35365
35366
35367 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35368 PyObject *resultobj;
35369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35370 wxItemKind arg2 ;
35371 PyObject * obj0 = 0 ;
35372 PyObject * obj1 = 0 ;
35373 char *kwnames[] = {
35374 (char *) "self",(char *) "kind", NULL
35375 };
35376
35377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35379 if (SWIG_arg_fail(1)) SWIG_fail;
35380 {
35381 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35382 if (SWIG_arg_fail(2)) SWIG_fail;
35383 }
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 (arg1)->SetKind((wxItemKind )arg2);
35387
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 Py_INCREF(Py_None); resultobj = Py_None;
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj;
35400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35401 bool arg2 ;
35402 PyObject * obj0 = 0 ;
35403 PyObject * obj1 = 0 ;
35404 char *kwnames[] = {
35405 (char *) "self",(char *) "checkable", NULL
35406 };
35407
35408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35410 if (SWIG_arg_fail(1)) SWIG_fail;
35411 {
35412 arg2 = (bool)(SWIG_As_bool(obj1));
35413 if (SWIG_arg_fail(2)) SWIG_fail;
35414 }
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 (arg1)->SetCheckable(arg2);
35418
35419 wxPyEndAllowThreads(__tstate);
35420 if (PyErr_Occurred()) SWIG_fail;
35421 }
35422 Py_INCREF(Py_None); resultobj = Py_None;
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35430 PyObject *resultobj;
35431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35432 bool result;
35433 PyObject * obj0 = 0 ;
35434 char *kwnames[] = {
35435 (char *) "self", NULL
35436 };
35437
35438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(1)) SWIG_fail;
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35444
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 {
35449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35450 }
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35458 PyObject *resultobj;
35459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35460 bool result;
35461 PyObject * obj0 = 0 ;
35462 char *kwnames[] = {
35463 (char *) "self", NULL
35464 };
35465
35466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35468 if (SWIG_arg_fail(1)) SWIG_fail;
35469 {
35470 PyThreadState* __tstate = wxPyBeginAllowThreads();
35471 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35472
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 {
35477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35478 }
35479 return resultobj;
35480 fail:
35481 return NULL;
35482 }
35483
35484
35485 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35486 PyObject *resultobj;
35487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35488 wxMenu *arg2 = (wxMenu *) 0 ;
35489 PyObject * obj0 = 0 ;
35490 PyObject * obj1 = 0 ;
35491 char *kwnames[] = {
35492 (char *) "self",(char *) "menu", NULL
35493 };
35494
35495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35497 if (SWIG_arg_fail(1)) SWIG_fail;
35498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35499 if (SWIG_arg_fail(2)) SWIG_fail;
35500 {
35501 PyThreadState* __tstate = wxPyBeginAllowThreads();
35502 (arg1)->SetSubMenu(arg2);
35503
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 Py_INCREF(Py_None); resultobj = Py_None;
35508 return resultobj;
35509 fail:
35510 return NULL;
35511 }
35512
35513
35514 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35515 PyObject *resultobj;
35516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35517 wxMenu *result;
35518 PyObject * obj0 = 0 ;
35519 char *kwnames[] = {
35520 (char *) "self", NULL
35521 };
35522
35523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35525 if (SWIG_arg_fail(1)) SWIG_fail;
35526 {
35527 PyThreadState* __tstate = wxPyBeginAllowThreads();
35528 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35529
35530 wxPyEndAllowThreads(__tstate);
35531 if (PyErr_Occurred()) SWIG_fail;
35532 }
35533 {
35534 resultobj = wxPyMake_wxObject(result, 0);
35535 }
35536 return resultobj;
35537 fail:
35538 return NULL;
35539 }
35540
35541
35542 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35543 PyObject *resultobj;
35544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35545 bool arg2 = (bool) true ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 char *kwnames[] = {
35549 (char *) "self",(char *) "enable", NULL
35550 };
35551
35552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35554 if (SWIG_arg_fail(1)) SWIG_fail;
35555 if (obj1) {
35556 {
35557 arg2 = (bool)(SWIG_As_bool(obj1));
35558 if (SWIG_arg_fail(2)) SWIG_fail;
35559 }
35560 }
35561 {
35562 PyThreadState* __tstate = wxPyBeginAllowThreads();
35563 (arg1)->Enable(arg2);
35564
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 Py_INCREF(Py_None); resultobj = Py_None;
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35576 PyObject *resultobj;
35577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35578 bool result;
35579 PyObject * obj0 = 0 ;
35580 char *kwnames[] = {
35581 (char *) "self", NULL
35582 };
35583
35584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35586 if (SWIG_arg_fail(1)) SWIG_fail;
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35590
35591 wxPyEndAllowThreads(__tstate);
35592 if (PyErr_Occurred()) SWIG_fail;
35593 }
35594 {
35595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35596 }
35597 return resultobj;
35598 fail:
35599 return NULL;
35600 }
35601
35602
35603 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35604 PyObject *resultobj;
35605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35606 bool arg2 = (bool) true ;
35607 PyObject * obj0 = 0 ;
35608 PyObject * obj1 = 0 ;
35609 char *kwnames[] = {
35610 (char *) "self",(char *) "check", NULL
35611 };
35612
35613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(1)) SWIG_fail;
35616 if (obj1) {
35617 {
35618 arg2 = (bool)(SWIG_As_bool(obj1));
35619 if (SWIG_arg_fail(2)) SWIG_fail;
35620 }
35621 }
35622 {
35623 PyThreadState* __tstate = wxPyBeginAllowThreads();
35624 (arg1)->Check(arg2);
35625
35626 wxPyEndAllowThreads(__tstate);
35627 if (PyErr_Occurred()) SWIG_fail;
35628 }
35629 Py_INCREF(Py_None); resultobj = Py_None;
35630 return resultobj;
35631 fail:
35632 return NULL;
35633 }
35634
35635
35636 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35637 PyObject *resultobj;
35638 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35639 bool result;
35640 PyObject * obj0 = 0 ;
35641 char *kwnames[] = {
35642 (char *) "self", NULL
35643 };
35644
35645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35647 if (SWIG_arg_fail(1)) SWIG_fail;
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35651
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 {
35656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35657 }
35658 return resultobj;
35659 fail:
35660 return NULL;
35661 }
35662
35663
35664 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35665 PyObject *resultobj;
35666 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35667 PyObject * obj0 = 0 ;
35668 char *kwnames[] = {
35669 (char *) "self", NULL
35670 };
35671
35672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35674 if (SWIG_arg_fail(1)) SWIG_fail;
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 (arg1)->Toggle();
35678
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 Py_INCREF(Py_None); resultobj = Py_None;
35683 return resultobj;
35684 fail:
35685 return NULL;
35686 }
35687
35688
35689 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35690 PyObject *resultobj;
35691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35692 wxString *arg2 = 0 ;
35693 bool temp2 = false ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 char *kwnames[] = {
35697 (char *) "self",(char *) "str", NULL
35698 };
35699
35700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35702 if (SWIG_arg_fail(1)) SWIG_fail;
35703 {
35704 arg2 = wxString_in_helper(obj1);
35705 if (arg2 == NULL) SWIG_fail;
35706 temp2 = true;
35707 }
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 (arg1)->SetHelp((wxString const &)*arg2);
35711
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 Py_INCREF(Py_None); resultobj = Py_None;
35716 {
35717 if (temp2)
35718 delete arg2;
35719 }
35720 return resultobj;
35721 fail:
35722 {
35723 if (temp2)
35724 delete arg2;
35725 }
35726 return NULL;
35727 }
35728
35729
35730 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35731 PyObject *resultobj;
35732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35733 wxString *result;
35734 PyObject * obj0 = 0 ;
35735 char *kwnames[] = {
35736 (char *) "self", NULL
35737 };
35738
35739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35741 if (SWIG_arg_fail(1)) SWIG_fail;
35742 {
35743 PyThreadState* __tstate = wxPyBeginAllowThreads();
35744 {
35745 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35746 result = (wxString *) &_result_ref;
35747 }
35748
35749 wxPyEndAllowThreads(__tstate);
35750 if (PyErr_Occurred()) SWIG_fail;
35751 }
35752 {
35753 #if wxUSE_UNICODE
35754 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35755 #else
35756 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35757 #endif
35758 }
35759 return resultobj;
35760 fail:
35761 return NULL;
35762 }
35763
35764
35765 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35766 PyObject *resultobj;
35767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35768 wxAcceleratorEntry *result;
35769 PyObject * obj0 = 0 ;
35770 char *kwnames[] = {
35771 (char *) "self", NULL
35772 };
35773
35774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35776 if (SWIG_arg_fail(1)) SWIG_fail;
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35780
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj;
35793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35794 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35795 PyObject * obj0 = 0 ;
35796 PyObject * obj1 = 0 ;
35797 char *kwnames[] = {
35798 (char *) "self",(char *) "accel", NULL
35799 };
35800
35801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35803 if (SWIG_arg_fail(1)) SWIG_fail;
35804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35805 if (SWIG_arg_fail(2)) SWIG_fail;
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 (arg1)->SetAccel(arg2);
35809
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 Py_INCREF(Py_None); resultobj = Py_None;
35814 return resultobj;
35815 fail:
35816 return NULL;
35817 }
35818
35819
35820 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj;
35822 int result;
35823 char *kwnames[] = {
35824 NULL
35825 };
35826
35827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (int)MenuItem_GetDefaultMarginWidth();
35831
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = SWIG_From_int((int)(result));
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35845 PyObject *resultobj;
35846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35847 wxBitmap *arg2 = 0 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char *kwnames[] = {
35851 (char *) "self",(char *) "bitmap", NULL
35852 };
35853
35854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35856 if (SWIG_arg_fail(1)) SWIG_fail;
35857 {
35858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35859 if (SWIG_arg_fail(2)) SWIG_fail;
35860 if (arg2 == NULL) {
35861 SWIG_null_ref("wxBitmap");
35862 }
35863 if (SWIG_arg_fail(2)) SWIG_fail;
35864 }
35865 {
35866 PyThreadState* __tstate = wxPyBeginAllowThreads();
35867 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35868
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 Py_INCREF(Py_None); resultobj = Py_None;
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj;
35881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35882 wxBitmap *result;
35883 PyObject * obj0 = 0 ;
35884 char *kwnames[] = {
35885 (char *) "self", NULL
35886 };
35887
35888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
35889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35890 if (SWIG_arg_fail(1)) SWIG_fail;
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 {
35894 wxBitmap const &_result_ref = (arg1)->GetBitmap();
35895 result = (wxBitmap *) &_result_ref;
35896 }
35897
35898 wxPyEndAllowThreads(__tstate);
35899 if (PyErr_Occurred()) SWIG_fail;
35900 }
35901 {
35902 wxBitmap* resultptr = new wxBitmap(*result);
35903 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
35904 }
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
35912 PyObject *obj;
35913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35914 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
35915 Py_INCREF(obj);
35916 return Py_BuildValue((char *)"");
35917 }
35918 static int _wrap_ControlNameStr_set(PyObject *) {
35919 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
35920 return 1;
35921 }
35922
35923
35924 static PyObject *_wrap_ControlNameStr_get(void) {
35925 PyObject *pyobj;
35926
35927 {
35928 #if wxUSE_UNICODE
35929 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35930 #else
35931 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35932 #endif
35933 }
35934 return pyobj;
35935 }
35936
35937
35938 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 int arg2 = (int) -1 ;
35942 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35943 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35944 wxSize const &arg4_defvalue = wxDefaultSize ;
35945 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35946 long arg5 = (long) 0 ;
35947 wxValidator const &arg6_defvalue = wxDefaultValidator ;
35948 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
35949 wxString const &arg7_defvalue = wxPyControlNameStr ;
35950 wxString *arg7 = (wxString *) &arg7_defvalue ;
35951 wxControl *result;
35952 wxPoint temp3 ;
35953 wxSize temp4 ;
35954 bool temp7 = false ;
35955 PyObject * obj0 = 0 ;
35956 PyObject * obj1 = 0 ;
35957 PyObject * obj2 = 0 ;
35958 PyObject * obj3 = 0 ;
35959 PyObject * obj4 = 0 ;
35960 PyObject * obj5 = 0 ;
35961 PyObject * obj6 = 0 ;
35962 char *kwnames[] = {
35963 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
35964 };
35965
35966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
35967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35968 if (SWIG_arg_fail(1)) SWIG_fail;
35969 if (obj1) {
35970 {
35971 arg2 = (int)(SWIG_As_int(obj1));
35972 if (SWIG_arg_fail(2)) SWIG_fail;
35973 }
35974 }
35975 if (obj2) {
35976 {
35977 arg3 = &temp3;
35978 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35979 }
35980 }
35981 if (obj3) {
35982 {
35983 arg4 = &temp4;
35984 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35985 }
35986 }
35987 if (obj4) {
35988 {
35989 arg5 = (long)(SWIG_As_long(obj4));
35990 if (SWIG_arg_fail(5)) SWIG_fail;
35991 }
35992 }
35993 if (obj5) {
35994 {
35995 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
35996 if (SWIG_arg_fail(6)) SWIG_fail;
35997 if (arg6 == NULL) {
35998 SWIG_null_ref("wxValidator");
35999 }
36000 if (SWIG_arg_fail(6)) SWIG_fail;
36001 }
36002 }
36003 if (obj6) {
36004 {
36005 arg7 = wxString_in_helper(obj6);
36006 if (arg7 == NULL) SWIG_fail;
36007 temp7 = true;
36008 }
36009 }
36010 {
36011 if (!wxPyCheckForApp()) SWIG_fail;
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36014
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36019 {
36020 if (temp7)
36021 delete arg7;
36022 }
36023 return resultobj;
36024 fail:
36025 {
36026 if (temp7)
36027 delete arg7;
36028 }
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxControl *result;
36036 char *kwnames[] = {
36037 NULL
36038 };
36039
36040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36041 {
36042 if (!wxPyCheckForApp()) SWIG_fail;
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (wxControl *)new wxControl();
36045
36046 wxPyEndAllowThreads(__tstate);
36047 if (PyErr_Occurred()) SWIG_fail;
36048 }
36049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj;
36058 wxControl *arg1 = (wxControl *) 0 ;
36059 wxWindow *arg2 = (wxWindow *) 0 ;
36060 int arg3 = (int) -1 ;
36061 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36062 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36063 wxSize const &arg5_defvalue = wxDefaultSize ;
36064 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36065 long arg6 = (long) 0 ;
36066 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36067 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36068 wxString const &arg8_defvalue = wxPyControlNameStr ;
36069 wxString *arg8 = (wxString *) &arg8_defvalue ;
36070 bool result;
36071 wxPoint temp4 ;
36072 wxSize temp5 ;
36073 bool temp8 = false ;
36074 PyObject * obj0 = 0 ;
36075 PyObject * obj1 = 0 ;
36076 PyObject * obj2 = 0 ;
36077 PyObject * obj3 = 0 ;
36078 PyObject * obj4 = 0 ;
36079 PyObject * obj5 = 0 ;
36080 PyObject * obj6 = 0 ;
36081 PyObject * obj7 = 0 ;
36082 char *kwnames[] = {
36083 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36084 };
36085
36086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36088 if (SWIG_arg_fail(1)) SWIG_fail;
36089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36090 if (SWIG_arg_fail(2)) SWIG_fail;
36091 if (obj2) {
36092 {
36093 arg3 = (int)(SWIG_As_int(obj2));
36094 if (SWIG_arg_fail(3)) SWIG_fail;
36095 }
36096 }
36097 if (obj3) {
36098 {
36099 arg4 = &temp4;
36100 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36101 }
36102 }
36103 if (obj4) {
36104 {
36105 arg5 = &temp5;
36106 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36107 }
36108 }
36109 if (obj5) {
36110 {
36111 arg6 = (long)(SWIG_As_long(obj5));
36112 if (SWIG_arg_fail(6)) SWIG_fail;
36113 }
36114 }
36115 if (obj6) {
36116 {
36117 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36118 if (SWIG_arg_fail(7)) SWIG_fail;
36119 if (arg7 == NULL) {
36120 SWIG_null_ref("wxValidator");
36121 }
36122 if (SWIG_arg_fail(7)) SWIG_fail;
36123 }
36124 }
36125 if (obj7) {
36126 {
36127 arg8 = wxString_in_helper(obj7);
36128 if (arg8 == NULL) SWIG_fail;
36129 temp8 = true;
36130 }
36131 }
36132 {
36133 PyThreadState* __tstate = wxPyBeginAllowThreads();
36134 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36135
36136 wxPyEndAllowThreads(__tstate);
36137 if (PyErr_Occurred()) SWIG_fail;
36138 }
36139 {
36140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36141 }
36142 {
36143 if (temp8)
36144 delete arg8;
36145 }
36146 return resultobj;
36147 fail:
36148 {
36149 if (temp8)
36150 delete arg8;
36151 }
36152 return NULL;
36153 }
36154
36155
36156 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36157 PyObject *resultobj;
36158 wxControl *arg1 = (wxControl *) 0 ;
36159 wxCommandEvent *arg2 = 0 ;
36160 PyObject * obj0 = 0 ;
36161 PyObject * obj1 = 0 ;
36162 char *kwnames[] = {
36163 (char *) "self",(char *) "event", NULL
36164 };
36165
36166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36168 if (SWIG_arg_fail(1)) SWIG_fail;
36169 {
36170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36171 if (SWIG_arg_fail(2)) SWIG_fail;
36172 if (arg2 == NULL) {
36173 SWIG_null_ref("wxCommandEvent");
36174 }
36175 if (SWIG_arg_fail(2)) SWIG_fail;
36176 }
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 (arg1)->Command(*arg2);
36180
36181 wxPyEndAllowThreads(__tstate);
36182 if (PyErr_Occurred()) SWIG_fail;
36183 }
36184 Py_INCREF(Py_None); resultobj = Py_None;
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj;
36193 wxControl *arg1 = (wxControl *) 0 ;
36194 wxString result;
36195 PyObject * obj0 = 0 ;
36196 char *kwnames[] = {
36197 (char *) "self", NULL
36198 };
36199
36200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36202 if (SWIG_arg_fail(1)) SWIG_fail;
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 result = (arg1)->GetLabel();
36206
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 {
36211 #if wxUSE_UNICODE
36212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36213 #else
36214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36215 #endif
36216 }
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj;
36225 wxControl *arg1 = (wxControl *) 0 ;
36226 wxString *arg2 = 0 ;
36227 bool temp2 = false ;
36228 PyObject * obj0 = 0 ;
36229 PyObject * obj1 = 0 ;
36230 char *kwnames[] = {
36231 (char *) "self",(char *) "label", NULL
36232 };
36233
36234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36236 if (SWIG_arg_fail(1)) SWIG_fail;
36237 {
36238 arg2 = wxString_in_helper(obj1);
36239 if (arg2 == NULL) SWIG_fail;
36240 temp2 = true;
36241 }
36242 {
36243 PyThreadState* __tstate = wxPyBeginAllowThreads();
36244 (arg1)->SetLabel((wxString const &)*arg2);
36245
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 Py_INCREF(Py_None); resultobj = Py_None;
36250 {
36251 if (temp2)
36252 delete arg2;
36253 }
36254 return resultobj;
36255 fail:
36256 {
36257 if (temp2)
36258 delete arg2;
36259 }
36260 return NULL;
36261 }
36262
36263
36264 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36265 PyObject *resultobj;
36266 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36267 wxVisualAttributes result;
36268 PyObject * obj0 = 0 ;
36269 char *kwnames[] = {
36270 (char *) "variant", NULL
36271 };
36272
36273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36274 if (obj0) {
36275 {
36276 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36277 if (SWIG_arg_fail(1)) SWIG_fail;
36278 }
36279 }
36280 {
36281 if (!wxPyCheckForApp()) SWIG_fail;
36282 PyThreadState* __tstate = wxPyBeginAllowThreads();
36283 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36284
36285 wxPyEndAllowThreads(__tstate);
36286 if (PyErr_Occurred()) SWIG_fail;
36287 }
36288 {
36289 wxVisualAttributes * resultptr;
36290 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36292 }
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36300 PyObject *obj;
36301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36302 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36303 Py_INCREF(obj);
36304 return Py_BuildValue((char *)"");
36305 }
36306 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36307 PyObject *resultobj;
36308 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36309 wxString *arg2 = 0 ;
36310 PyObject *arg3 = (PyObject *) NULL ;
36311 int result;
36312 bool temp2 = false ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 PyObject * obj2 = 0 ;
36316 char *kwnames[] = {
36317 (char *) "self",(char *) "item",(char *) "clientData", NULL
36318 };
36319
36320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36322 if (SWIG_arg_fail(1)) SWIG_fail;
36323 {
36324 arg2 = wxString_in_helper(obj1);
36325 if (arg2 == NULL) SWIG_fail;
36326 temp2 = true;
36327 }
36328 if (obj2) {
36329 arg3 = obj2;
36330 }
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36334
36335 wxPyEndAllowThreads(__tstate);
36336 if (PyErr_Occurred()) SWIG_fail;
36337 }
36338 {
36339 resultobj = SWIG_From_int((int)(result));
36340 }
36341 {
36342 if (temp2)
36343 delete arg2;
36344 }
36345 return resultobj;
36346 fail:
36347 {
36348 if (temp2)
36349 delete arg2;
36350 }
36351 return NULL;
36352 }
36353
36354
36355 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj;
36357 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36358 wxArrayString *arg2 = 0 ;
36359 bool temp2 = false ;
36360 PyObject * obj0 = 0 ;
36361 PyObject * obj1 = 0 ;
36362 char *kwnames[] = {
36363 (char *) "self",(char *) "strings", NULL
36364 };
36365
36366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36368 if (SWIG_arg_fail(1)) SWIG_fail;
36369 {
36370 if (! PySequence_Check(obj1)) {
36371 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36372 SWIG_fail;
36373 }
36374 arg2 = new wxArrayString;
36375 temp2 = true;
36376 int i, len=PySequence_Length(obj1);
36377 for (i=0; i<len; i++) {
36378 PyObject* item = PySequence_GetItem(obj1, i);
36379 #if wxUSE_UNICODE
36380 PyObject* str = PyObject_Unicode(item);
36381 #else
36382 PyObject* str = PyObject_Str(item);
36383 #endif
36384 if (PyErr_Occurred()) SWIG_fail;
36385 arg2->Add(Py2wxString(str));
36386 Py_DECREF(item);
36387 Py_DECREF(str);
36388 }
36389 }
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 (arg1)->Append((wxArrayString const &)*arg2);
36393
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 Py_INCREF(Py_None); resultobj = Py_None;
36398 {
36399 if (temp2) delete arg2;
36400 }
36401 return resultobj;
36402 fail:
36403 {
36404 if (temp2) delete arg2;
36405 }
36406 return NULL;
36407 }
36408
36409
36410 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36411 PyObject *resultobj;
36412 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36413 wxString *arg2 = 0 ;
36414 int arg3 ;
36415 PyObject *arg4 = (PyObject *) NULL ;
36416 int result;
36417 bool temp2 = false ;
36418 PyObject * obj0 = 0 ;
36419 PyObject * obj1 = 0 ;
36420 PyObject * obj2 = 0 ;
36421 PyObject * obj3 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 arg2 = wxString_in_helper(obj1);
36431 if (arg2 == NULL) SWIG_fail;
36432 temp2 = true;
36433 }
36434 {
36435 arg3 = (int)(SWIG_As_int(obj2));
36436 if (SWIG_arg_fail(3)) SWIG_fail;
36437 }
36438 if (obj3) {
36439 arg4 = obj3;
36440 }
36441 {
36442 PyThreadState* __tstate = wxPyBeginAllowThreads();
36443 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36444
36445 wxPyEndAllowThreads(__tstate);
36446 if (PyErr_Occurred()) SWIG_fail;
36447 }
36448 {
36449 resultobj = SWIG_From_int((int)(result));
36450 }
36451 {
36452 if (temp2)
36453 delete arg2;
36454 }
36455 return resultobj;
36456 fail:
36457 {
36458 if (temp2)
36459 delete arg2;
36460 }
36461 return NULL;
36462 }
36463
36464
36465 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36466 PyObject *resultobj;
36467 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36468 PyObject * obj0 = 0 ;
36469 char *kwnames[] = {
36470 (char *) "self", NULL
36471 };
36472
36473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36475 if (SWIG_arg_fail(1)) SWIG_fail;
36476 {
36477 PyThreadState* __tstate = wxPyBeginAllowThreads();
36478 (arg1)->Clear();
36479
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 Py_INCREF(Py_None); resultobj = Py_None;
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36491 PyObject *resultobj;
36492 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36493 int arg2 ;
36494 PyObject * obj0 = 0 ;
36495 PyObject * obj1 = 0 ;
36496 char *kwnames[] = {
36497 (char *) "self",(char *) "n", NULL
36498 };
36499
36500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36502 if (SWIG_arg_fail(1)) SWIG_fail;
36503 {
36504 arg2 = (int)(SWIG_As_int(obj1));
36505 if (SWIG_arg_fail(2)) SWIG_fail;
36506 }
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 (arg1)->Delete(arg2);
36510
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 Py_INCREF(Py_None); resultobj = Py_None;
36515 return resultobj;
36516 fail:
36517 return NULL;
36518 }
36519
36520
36521 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36522 PyObject *resultobj;
36523 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36524 int result;
36525 PyObject * obj0 = 0 ;
36526 char *kwnames[] = {
36527 (char *) "self", NULL
36528 };
36529
36530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36532 if (SWIG_arg_fail(1)) SWIG_fail;
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 result = (int)((wxItemContainer const *)arg1)->GetCount();
36536
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 {
36541 resultobj = SWIG_From_int((int)(result));
36542 }
36543 return resultobj;
36544 fail:
36545 return NULL;
36546 }
36547
36548
36549 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36550 PyObject *resultobj;
36551 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36552 bool result;
36553 PyObject * obj0 = 0 ;
36554 char *kwnames[] = {
36555 (char *) "self", NULL
36556 };
36557
36558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36560 if (SWIG_arg_fail(1)) SWIG_fail;
36561 {
36562 PyThreadState* __tstate = wxPyBeginAllowThreads();
36563 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36564
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 {
36569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36570 }
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj;
36579 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36580 int arg2 ;
36581 wxString result;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char *kwnames[] = {
36585 (char *) "self",(char *) "n", NULL
36586 };
36587
36588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36590 if (SWIG_arg_fail(1)) SWIG_fail;
36591 {
36592 arg2 = (int)(SWIG_As_int(obj1));
36593 if (SWIG_arg_fail(2)) SWIG_fail;
36594 }
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36598
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 {
36603 #if wxUSE_UNICODE
36604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36605 #else
36606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36607 #endif
36608 }
36609 return resultobj;
36610 fail:
36611 return NULL;
36612 }
36613
36614
36615 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36616 PyObject *resultobj;
36617 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36618 wxArrayString result;
36619 PyObject * obj0 = 0 ;
36620 char *kwnames[] = {
36621 (char *) "self", NULL
36622 };
36623
36624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36626 if (SWIG_arg_fail(1)) SWIG_fail;
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 result = ((wxItemContainer const *)arg1)->GetStrings();
36630
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 {
36635 resultobj = wxArrayString2PyList_helper(result);
36636 }
36637 return resultobj;
36638 fail:
36639 return NULL;
36640 }
36641
36642
36643 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36644 PyObject *resultobj;
36645 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36646 int arg2 ;
36647 wxString *arg3 = 0 ;
36648 bool temp3 = false ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 PyObject * obj2 = 0 ;
36652 char *kwnames[] = {
36653 (char *) "self",(char *) "n",(char *) "s", NULL
36654 };
36655
36656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36658 if (SWIG_arg_fail(1)) SWIG_fail;
36659 {
36660 arg2 = (int)(SWIG_As_int(obj1));
36661 if (SWIG_arg_fail(2)) SWIG_fail;
36662 }
36663 {
36664 arg3 = wxString_in_helper(obj2);
36665 if (arg3 == NULL) SWIG_fail;
36666 temp3 = true;
36667 }
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 (arg1)->SetString(arg2,(wxString const &)*arg3);
36671
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 Py_INCREF(Py_None); resultobj = Py_None;
36676 {
36677 if (temp3)
36678 delete arg3;
36679 }
36680 return resultobj;
36681 fail:
36682 {
36683 if (temp3)
36684 delete arg3;
36685 }
36686 return NULL;
36687 }
36688
36689
36690 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36691 PyObject *resultobj;
36692 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36693 wxString *arg2 = 0 ;
36694 int result;
36695 bool temp2 = false ;
36696 PyObject * obj0 = 0 ;
36697 PyObject * obj1 = 0 ;
36698 char *kwnames[] = {
36699 (char *) "self",(char *) "s", NULL
36700 };
36701
36702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36704 if (SWIG_arg_fail(1)) SWIG_fail;
36705 {
36706 arg2 = wxString_in_helper(obj1);
36707 if (arg2 == NULL) SWIG_fail;
36708 temp2 = true;
36709 }
36710 {
36711 PyThreadState* __tstate = wxPyBeginAllowThreads();
36712 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36713
36714 wxPyEndAllowThreads(__tstate);
36715 if (PyErr_Occurred()) SWIG_fail;
36716 }
36717 {
36718 resultobj = SWIG_From_int((int)(result));
36719 }
36720 {
36721 if (temp2)
36722 delete arg2;
36723 }
36724 return resultobj;
36725 fail:
36726 {
36727 if (temp2)
36728 delete arg2;
36729 }
36730 return NULL;
36731 }
36732
36733
36734 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
36735 PyObject *resultobj;
36736 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36737 int arg2 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char *kwnames[] = {
36741 (char *) "self",(char *) "n", NULL
36742 };
36743
36744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
36745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36746 if (SWIG_arg_fail(1)) SWIG_fail;
36747 {
36748 arg2 = (int)(SWIG_As_int(obj1));
36749 if (SWIG_arg_fail(2)) SWIG_fail;
36750 }
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 (arg1)->Select(arg2);
36754
36755 wxPyEndAllowThreads(__tstate);
36756 if (PyErr_Occurred()) SWIG_fail;
36757 }
36758 Py_INCREF(Py_None); resultobj = Py_None;
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36766 PyObject *resultobj;
36767 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36768 int result;
36769 PyObject * obj0 = 0 ;
36770 char *kwnames[] = {
36771 (char *) "self", NULL
36772 };
36773
36774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36776 if (SWIG_arg_fail(1)) SWIG_fail;
36777 {
36778 PyThreadState* __tstate = wxPyBeginAllowThreads();
36779 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36780
36781 wxPyEndAllowThreads(__tstate);
36782 if (PyErr_Occurred()) SWIG_fail;
36783 }
36784 {
36785 resultobj = SWIG_From_int((int)(result));
36786 }
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36794 PyObject *resultobj;
36795 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36796 wxString result;
36797 PyObject * obj0 = 0 ;
36798 char *kwnames[] = {
36799 (char *) "self", NULL
36800 };
36801
36802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
36803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36804 if (SWIG_arg_fail(1)) SWIG_fail;
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 result = ((wxItemContainer const *)arg1)->GetStringSelection();
36808
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 #if wxUSE_UNICODE
36814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36815 #else
36816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36817 #endif
36818 }
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36826 PyObject *resultobj;
36827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36828 int arg2 ;
36829 PyObject *result;
36830 PyObject * obj0 = 0 ;
36831 PyObject * obj1 = 0 ;
36832 char *kwnames[] = {
36833 (char *) "self",(char *) "n", NULL
36834 };
36835
36836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36838 if (SWIG_arg_fail(1)) SWIG_fail;
36839 {
36840 arg2 = (int)(SWIG_As_int(obj1));
36841 if (SWIG_arg_fail(2)) SWIG_fail;
36842 }
36843 {
36844 PyThreadState* __tstate = wxPyBeginAllowThreads();
36845 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36846
36847 wxPyEndAllowThreads(__tstate);
36848 if (PyErr_Occurred()) SWIG_fail;
36849 }
36850 resultobj = result;
36851 return resultobj;
36852 fail:
36853 return NULL;
36854 }
36855
36856
36857 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36858 PyObject *resultobj;
36859 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36860 int arg2 ;
36861 PyObject *arg3 = (PyObject *) 0 ;
36862 PyObject * obj0 = 0 ;
36863 PyObject * obj1 = 0 ;
36864 PyObject * obj2 = 0 ;
36865 char *kwnames[] = {
36866 (char *) "self",(char *) "n",(char *) "clientData", NULL
36867 };
36868
36869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36871 if (SWIG_arg_fail(1)) SWIG_fail;
36872 {
36873 arg2 = (int)(SWIG_As_int(obj1));
36874 if (SWIG_arg_fail(2)) SWIG_fail;
36875 }
36876 arg3 = obj2;
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 wxItemContainer_SetClientData(arg1,arg2,arg3);
36880
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 Py_INCREF(Py_None); resultobj = Py_None;
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
36892 PyObject *obj;
36893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36894 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
36895 Py_INCREF(obj);
36896 return Py_BuildValue((char *)"");
36897 }
36898 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
36899 PyObject *obj;
36900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36901 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
36902 Py_INCREF(obj);
36903 return Py_BuildValue((char *)"");
36904 }
36905 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
36906 PyObject *resultobj;
36907 wxSizerItem *result;
36908 char *kwnames[] = {
36909 NULL
36910 };
36911
36912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
36913 {
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 result = (wxSizerItem *)new wxSizerItem();
36916
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 int arg2 ;
36931 int arg3 ;
36932 int arg4 ;
36933 PyObject *arg5 = (PyObject *) NULL ;
36934 wxSizerItem *result;
36935 PyObject * obj0 = 0 ;
36936 PyObject * obj1 = 0 ;
36937 PyObject * obj2 = 0 ;
36938 PyObject * obj3 = 0 ;
36939 PyObject * obj4 = 0 ;
36940 char *kwnames[] = {
36941 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
36942 };
36943
36944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
36945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36946 if (SWIG_arg_fail(1)) SWIG_fail;
36947 {
36948 arg2 = (int)(SWIG_As_int(obj1));
36949 if (SWIG_arg_fail(2)) SWIG_fail;
36950 }
36951 {
36952 arg3 = (int)(SWIG_As_int(obj2));
36953 if (SWIG_arg_fail(3)) SWIG_fail;
36954 }
36955 {
36956 arg4 = (int)(SWIG_As_int(obj3));
36957 if (SWIG_arg_fail(4)) SWIG_fail;
36958 }
36959 if (obj4) {
36960 arg5 = obj4;
36961 }
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
36965
36966 wxPyEndAllowThreads(__tstate);
36967 if (PyErr_Occurred()) SWIG_fail;
36968 }
36969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj;
36978 int arg1 ;
36979 int arg2 ;
36980 int arg3 ;
36981 int arg4 ;
36982 int arg5 ;
36983 PyObject *arg6 = (PyObject *) NULL ;
36984 wxSizerItem *result;
36985 PyObject * obj0 = 0 ;
36986 PyObject * obj1 = 0 ;
36987 PyObject * obj2 = 0 ;
36988 PyObject * obj3 = 0 ;
36989 PyObject * obj4 = 0 ;
36990 PyObject * obj5 = 0 ;
36991 char *kwnames[] = {
36992 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
36993 };
36994
36995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36996 {
36997 arg1 = (int)(SWIG_As_int(obj0));
36998 if (SWIG_arg_fail(1)) SWIG_fail;
36999 }
37000 {
37001 arg2 = (int)(SWIG_As_int(obj1));
37002 if (SWIG_arg_fail(2)) SWIG_fail;
37003 }
37004 {
37005 arg3 = (int)(SWIG_As_int(obj2));
37006 if (SWIG_arg_fail(3)) SWIG_fail;
37007 }
37008 {
37009 arg4 = (int)(SWIG_As_int(obj3));
37010 if (SWIG_arg_fail(4)) SWIG_fail;
37011 }
37012 {
37013 arg5 = (int)(SWIG_As_int(obj4));
37014 if (SWIG_arg_fail(5)) SWIG_fail;
37015 }
37016 if (obj5) {
37017 arg6 = obj5;
37018 }
37019 {
37020 PyThreadState* __tstate = wxPyBeginAllowThreads();
37021 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37022
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj;
37035 wxSizer *arg1 = (wxSizer *) 0 ;
37036 int arg2 ;
37037 int arg3 ;
37038 int arg4 ;
37039 PyObject *arg5 = (PyObject *) NULL ;
37040 wxSizerItem *result;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 PyObject * obj2 = 0 ;
37044 PyObject * obj3 = 0 ;
37045 PyObject * obj4 = 0 ;
37046 char *kwnames[] = {
37047 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37048 };
37049
37050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37052 if (SWIG_arg_fail(1)) SWIG_fail;
37053 {
37054 arg2 = (int)(SWIG_As_int(obj1));
37055 if (SWIG_arg_fail(2)) SWIG_fail;
37056 }
37057 {
37058 arg3 = (int)(SWIG_As_int(obj2));
37059 if (SWIG_arg_fail(3)) SWIG_fail;
37060 }
37061 {
37062 arg4 = (int)(SWIG_As_int(obj3));
37063 if (SWIG_arg_fail(4)) SWIG_fail;
37064 }
37065 if (obj4) {
37066 arg5 = obj4;
37067 }
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37071
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj;
37084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37085 PyObject * obj0 = 0 ;
37086 char *kwnames[] = {
37087 (char *) "self", NULL
37088 };
37089
37090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37092 if (SWIG_arg_fail(1)) SWIG_fail;
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->DeleteWindows();
37096
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 Py_INCREF(Py_None); resultobj = Py_None;
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37108 PyObject *resultobj;
37109 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37110 PyObject * obj0 = 0 ;
37111 char *kwnames[] = {
37112 (char *) "self", NULL
37113 };
37114
37115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37117 if (SWIG_arg_fail(1)) SWIG_fail;
37118 {
37119 PyThreadState* __tstate = wxPyBeginAllowThreads();
37120 (arg1)->DetachSizer();
37121
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 Py_INCREF(Py_None); resultobj = Py_None;
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj;
37134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37135 wxSize result;
37136 PyObject * obj0 = 0 ;
37137 char *kwnames[] = {
37138 (char *) "self", NULL
37139 };
37140
37141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37143 if (SWIG_arg_fail(1)) SWIG_fail;
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = (arg1)->GetSize();
37147
37148 wxPyEndAllowThreads(__tstate);
37149 if (PyErr_Occurred()) SWIG_fail;
37150 }
37151 {
37152 wxSize * resultptr;
37153 resultptr = new wxSize((wxSize &)(result));
37154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37155 }
37156 return resultobj;
37157 fail:
37158 return NULL;
37159 }
37160
37161
37162 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37163 PyObject *resultobj;
37164 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37165 wxSize result;
37166 PyObject * obj0 = 0 ;
37167 char *kwnames[] = {
37168 (char *) "self", NULL
37169 };
37170
37171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37173 if (SWIG_arg_fail(1)) SWIG_fail;
37174 {
37175 PyThreadState* __tstate = wxPyBeginAllowThreads();
37176 result = (arg1)->CalcMin();
37177
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 {
37182 wxSize * resultptr;
37183 resultptr = new wxSize((wxSize &)(result));
37184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37185 }
37186 return resultobj;
37187 fail:
37188 return NULL;
37189 }
37190
37191
37192 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37193 PyObject *resultobj;
37194 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37195 wxPoint arg2 ;
37196 wxSize arg3 ;
37197 PyObject * obj0 = 0 ;
37198 PyObject * obj1 = 0 ;
37199 PyObject * obj2 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self",(char *) "pos",(char *) "size", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 wxPoint * argp;
37209 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37210 if (SWIG_arg_fail(2)) SWIG_fail;
37211 if (argp == NULL) {
37212 SWIG_null_ref("wxPoint");
37213 }
37214 if (SWIG_arg_fail(2)) SWIG_fail;
37215 arg2 = *argp;
37216 }
37217 {
37218 wxSize * argp;
37219 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37220 if (SWIG_arg_fail(3)) SWIG_fail;
37221 if (argp == NULL) {
37222 SWIG_null_ref("wxSize");
37223 }
37224 if (SWIG_arg_fail(3)) SWIG_fail;
37225 arg3 = *argp;
37226 }
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 (arg1)->SetDimension(arg2,arg3);
37230
37231 wxPyEndAllowThreads(__tstate);
37232 if (PyErr_Occurred()) SWIG_fail;
37233 }
37234 Py_INCREF(Py_None); resultobj = Py_None;
37235 return resultobj;
37236 fail:
37237 return NULL;
37238 }
37239
37240
37241 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37242 PyObject *resultobj;
37243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37244 wxSize result;
37245 PyObject * obj0 = 0 ;
37246 char *kwnames[] = {
37247 (char *) "self", NULL
37248 };
37249
37250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37252 if (SWIG_arg_fail(1)) SWIG_fail;
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 result = (arg1)->GetMinSize();
37256
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 {
37261 wxSize * resultptr;
37262 resultptr = new wxSize((wxSize &)(result));
37263 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37264 }
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37272 PyObject *resultobj;
37273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37274 wxSize result;
37275 PyObject * obj0 = 0 ;
37276 char *kwnames[] = {
37277 (char *) "self", NULL
37278 };
37279
37280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37282 if (SWIG_arg_fail(1)) SWIG_fail;
37283 {
37284 PyThreadState* __tstate = wxPyBeginAllowThreads();
37285 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37286
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 wxSize * resultptr;
37292 resultptr = new wxSize((wxSize &)(result));
37293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj;
37303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37304 int arg2 ;
37305 int arg3 ;
37306 PyObject * obj0 = 0 ;
37307 PyObject * obj1 = 0 ;
37308 PyObject * obj2 = 0 ;
37309 char *kwnames[] = {
37310 (char *) "self",(char *) "x",(char *) "y", NULL
37311 };
37312
37313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37315 if (SWIG_arg_fail(1)) SWIG_fail;
37316 {
37317 arg2 = (int)(SWIG_As_int(obj1));
37318 if (SWIG_arg_fail(2)) SWIG_fail;
37319 }
37320 {
37321 arg3 = (int)(SWIG_As_int(obj2));
37322 if (SWIG_arg_fail(3)) SWIG_fail;
37323 }
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 (arg1)->SetInitSize(arg2,arg3);
37327
37328 wxPyEndAllowThreads(__tstate);
37329 if (PyErr_Occurred()) SWIG_fail;
37330 }
37331 Py_INCREF(Py_None); resultobj = Py_None;
37332 return resultobj;
37333 fail:
37334 return NULL;
37335 }
37336
37337
37338 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37339 PyObject *resultobj;
37340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37341 int arg2 ;
37342 int arg3 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 PyObject * obj2 = 0 ;
37346 char *kwnames[] = {
37347 (char *) "self",(char *) "width",(char *) "height", NULL
37348 };
37349
37350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37352 if (SWIG_arg_fail(1)) SWIG_fail;
37353 {
37354 arg2 = (int)(SWIG_As_int(obj1));
37355 if (SWIG_arg_fail(2)) SWIG_fail;
37356 }
37357 {
37358 arg3 = (int)(SWIG_As_int(obj2));
37359 if (SWIG_arg_fail(3)) SWIG_fail;
37360 }
37361 {
37362 PyThreadState* __tstate = wxPyBeginAllowThreads();
37363 (arg1)->SetRatio(arg2,arg3);
37364
37365 wxPyEndAllowThreads(__tstate);
37366 if (PyErr_Occurred()) SWIG_fail;
37367 }
37368 Py_INCREF(Py_None); resultobj = Py_None;
37369 return resultobj;
37370 fail:
37371 return NULL;
37372 }
37373
37374
37375 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj;
37377 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37378 wxSize arg2 ;
37379 PyObject * obj0 = 0 ;
37380 PyObject * obj1 = 0 ;
37381 char *kwnames[] = {
37382 (char *) "self",(char *) "size", NULL
37383 };
37384
37385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37387 if (SWIG_arg_fail(1)) SWIG_fail;
37388 {
37389 wxSize * argp;
37390 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37391 if (SWIG_arg_fail(2)) SWIG_fail;
37392 if (argp == NULL) {
37393 SWIG_null_ref("wxSize");
37394 }
37395 if (SWIG_arg_fail(2)) SWIG_fail;
37396 arg2 = *argp;
37397 }
37398 {
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 (arg1)->SetRatio(arg2);
37401
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 Py_INCREF(Py_None); resultobj = Py_None;
37406 return resultobj;
37407 fail:
37408 return NULL;
37409 }
37410
37411
37412 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37413 PyObject *resultobj;
37414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37415 float arg2 ;
37416 PyObject * obj0 = 0 ;
37417 PyObject * obj1 = 0 ;
37418 char *kwnames[] = {
37419 (char *) "self",(char *) "ratio", NULL
37420 };
37421
37422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37424 if (SWIG_arg_fail(1)) SWIG_fail;
37425 {
37426 arg2 = (float)(SWIG_As_float(obj1));
37427 if (SWIG_arg_fail(2)) SWIG_fail;
37428 }
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 (arg1)->SetRatio(arg2);
37432
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 Py_INCREF(Py_None); resultobj = Py_None;
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj;
37445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37446 float result;
37447 PyObject * obj0 = 0 ;
37448 char *kwnames[] = {
37449 (char *) "self", NULL
37450 };
37451
37452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37454 if (SWIG_arg_fail(1)) SWIG_fail;
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (float)(arg1)->GetRatio();
37458
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 {
37463 resultobj = SWIG_From_float((float)(result));
37464 }
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37472 PyObject *resultobj;
37473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37474 wxRect result;
37475 PyObject * obj0 = 0 ;
37476 char *kwnames[] = {
37477 (char *) "self", NULL
37478 };
37479
37480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37482 if (SWIG_arg_fail(1)) SWIG_fail;
37483 {
37484 PyThreadState* __tstate = wxPyBeginAllowThreads();
37485 result = (arg1)->GetRect();
37486
37487 wxPyEndAllowThreads(__tstate);
37488 if (PyErr_Occurred()) SWIG_fail;
37489 }
37490 {
37491 wxRect * resultptr;
37492 resultptr = new wxRect((wxRect &)(result));
37493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37494 }
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj;
37503 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37504 bool result;
37505 PyObject * obj0 = 0 ;
37506 char *kwnames[] = {
37507 (char *) "self", NULL
37508 };
37509
37510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37512 if (SWIG_arg_fail(1)) SWIG_fail;
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 result = (bool)(arg1)->IsWindow();
37516
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 {
37521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37522 }
37523 return resultobj;
37524 fail:
37525 return NULL;
37526 }
37527
37528
37529 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37530 PyObject *resultobj;
37531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37532 bool result;
37533 PyObject * obj0 = 0 ;
37534 char *kwnames[] = {
37535 (char *) "self", NULL
37536 };
37537
37538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37540 if (SWIG_arg_fail(1)) SWIG_fail;
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (bool)(arg1)->IsSizer();
37544
37545 wxPyEndAllowThreads(__tstate);
37546 if (PyErr_Occurred()) SWIG_fail;
37547 }
37548 {
37549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37550 }
37551 return resultobj;
37552 fail:
37553 return NULL;
37554 }
37555
37556
37557 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37558 PyObject *resultobj;
37559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37560 bool result;
37561 PyObject * obj0 = 0 ;
37562 char *kwnames[] = {
37563 (char *) "self", NULL
37564 };
37565
37566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37568 if (SWIG_arg_fail(1)) SWIG_fail;
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (bool)(arg1)->IsSpacer();
37572
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 return resultobj;
37580 fail:
37581 return NULL;
37582 }
37583
37584
37585 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37586 PyObject *resultobj;
37587 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37588 int arg2 ;
37589 PyObject * obj0 = 0 ;
37590 PyObject * obj1 = 0 ;
37591 char *kwnames[] = {
37592 (char *) "self",(char *) "proportion", NULL
37593 };
37594
37595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37597 if (SWIG_arg_fail(1)) SWIG_fail;
37598 {
37599 arg2 = (int)(SWIG_As_int(obj1));
37600 if (SWIG_arg_fail(2)) SWIG_fail;
37601 }
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 (arg1)->SetProportion(arg2);
37605
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 Py_INCREF(Py_None); resultobj = Py_None;
37610 return resultobj;
37611 fail:
37612 return NULL;
37613 }
37614
37615
37616 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37617 PyObject *resultobj;
37618 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37619 int result;
37620 PyObject * obj0 = 0 ;
37621 char *kwnames[] = {
37622 (char *) "self", NULL
37623 };
37624
37625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37627 if (SWIG_arg_fail(1)) SWIG_fail;
37628 {
37629 PyThreadState* __tstate = wxPyBeginAllowThreads();
37630 result = (int)(arg1)->GetProportion();
37631
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 {
37636 resultobj = SWIG_From_int((int)(result));
37637 }
37638 return resultobj;
37639 fail:
37640 return NULL;
37641 }
37642
37643
37644 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37645 PyObject *resultobj;
37646 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37647 int arg2 ;
37648 PyObject * obj0 = 0 ;
37649 PyObject * obj1 = 0 ;
37650 char *kwnames[] = {
37651 (char *) "self",(char *) "flag", NULL
37652 };
37653
37654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37656 if (SWIG_arg_fail(1)) SWIG_fail;
37657 {
37658 arg2 = (int)(SWIG_As_int(obj1));
37659 if (SWIG_arg_fail(2)) SWIG_fail;
37660 }
37661 {
37662 PyThreadState* __tstate = wxPyBeginAllowThreads();
37663 (arg1)->SetFlag(arg2);
37664
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 Py_INCREF(Py_None); resultobj = Py_None;
37669 return resultobj;
37670 fail:
37671 return NULL;
37672 }
37673
37674
37675 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37676 PyObject *resultobj;
37677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37678 int result;
37679 PyObject * obj0 = 0 ;
37680 char *kwnames[] = {
37681 (char *) "self", NULL
37682 };
37683
37684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37686 if (SWIG_arg_fail(1)) SWIG_fail;
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 result = (int)(arg1)->GetFlag();
37690
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 {
37695 resultobj = SWIG_From_int((int)(result));
37696 }
37697 return resultobj;
37698 fail:
37699 return NULL;
37700 }
37701
37702
37703 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37704 PyObject *resultobj;
37705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37706 int arg2 ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char *kwnames[] = {
37710 (char *) "self",(char *) "border", NULL
37711 };
37712
37713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(1)) SWIG_fail;
37716 {
37717 arg2 = (int)(SWIG_As_int(obj1));
37718 if (SWIG_arg_fail(2)) SWIG_fail;
37719 }
37720 {
37721 PyThreadState* __tstate = wxPyBeginAllowThreads();
37722 (arg1)->SetBorder(arg2);
37723
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 Py_INCREF(Py_None); resultobj = Py_None;
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj;
37736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37737 int result;
37738 PyObject * obj0 = 0 ;
37739 char *kwnames[] = {
37740 (char *) "self", NULL
37741 };
37742
37743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
37744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37745 if (SWIG_arg_fail(1)) SWIG_fail;
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 result = (int)(arg1)->GetBorder();
37749
37750 wxPyEndAllowThreads(__tstate);
37751 if (PyErr_Occurred()) SWIG_fail;
37752 }
37753 {
37754 resultobj = SWIG_From_int((int)(result));
37755 }
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37763 PyObject *resultobj;
37764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37765 wxWindow *result;
37766 PyObject * obj0 = 0 ;
37767 char *kwnames[] = {
37768 (char *) "self", NULL
37769 };
37770
37771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
37772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37773 if (SWIG_arg_fail(1)) SWIG_fail;
37774 {
37775 PyThreadState* __tstate = wxPyBeginAllowThreads();
37776 result = (wxWindow *)(arg1)->GetWindow();
37777
37778 wxPyEndAllowThreads(__tstate);
37779 if (PyErr_Occurred()) SWIG_fail;
37780 }
37781 {
37782 resultobj = wxPyMake_wxObject(result, 0);
37783 }
37784 return resultobj;
37785 fail:
37786 return NULL;
37787 }
37788
37789
37790 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37791 PyObject *resultobj;
37792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37793 wxWindow *arg2 = (wxWindow *) 0 ;
37794 PyObject * obj0 = 0 ;
37795 PyObject * obj1 = 0 ;
37796 char *kwnames[] = {
37797 (char *) "self",(char *) "window", NULL
37798 };
37799
37800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37802 if (SWIG_arg_fail(1)) SWIG_fail;
37803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37804 if (SWIG_arg_fail(2)) SWIG_fail;
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 (arg1)->SetWindow(arg2);
37808
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 Py_INCREF(Py_None); resultobj = Py_None;
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj;
37821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37822 wxSizer *result;
37823 PyObject * obj0 = 0 ;
37824 char *kwnames[] = {
37825 (char *) "self", NULL
37826 };
37827
37828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
37829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37830 if (SWIG_arg_fail(1)) SWIG_fail;
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 result = (wxSizer *)(arg1)->GetSizer();
37834
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 {
37839 resultobj = wxPyMake_wxSizer(result, 0);
37840 }
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37848 PyObject *resultobj;
37849 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37850 wxSizer *arg2 = (wxSizer *) 0 ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 char *kwnames[] = {
37854 (char *) "self",(char *) "sizer", NULL
37855 };
37856
37857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
37858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37859 if (SWIG_arg_fail(1)) SWIG_fail;
37860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37861 if (SWIG_arg_fail(2)) SWIG_fail;
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 (arg1)->SetSizer(arg2);
37865
37866 wxPyEndAllowThreads(__tstate);
37867 if (PyErr_Occurred()) SWIG_fail;
37868 }
37869 Py_INCREF(Py_None); resultobj = Py_None;
37870 return resultobj;
37871 fail:
37872 return NULL;
37873 }
37874
37875
37876 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37877 PyObject *resultobj;
37878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37879 wxSize *result;
37880 PyObject * obj0 = 0 ;
37881 char *kwnames[] = {
37882 (char *) "self", NULL
37883 };
37884
37885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
37886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37887 if (SWIG_arg_fail(1)) SWIG_fail;
37888 {
37889 PyThreadState* __tstate = wxPyBeginAllowThreads();
37890 {
37891 wxSize const &_result_ref = (arg1)->GetSpacer();
37892 result = (wxSize *) &_result_ref;
37893 }
37894
37895 wxPyEndAllowThreads(__tstate);
37896 if (PyErr_Occurred()) SWIG_fail;
37897 }
37898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
37899 return resultobj;
37900 fail:
37901 return NULL;
37902 }
37903
37904
37905 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37906 PyObject *resultobj;
37907 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37908 wxSize *arg2 = 0 ;
37909 wxSize temp2 ;
37910 PyObject * obj0 = 0 ;
37911 PyObject * obj1 = 0 ;
37912 char *kwnames[] = {
37913 (char *) "self",(char *) "size", NULL
37914 };
37915
37916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
37917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37918 if (SWIG_arg_fail(1)) SWIG_fail;
37919 {
37920 arg2 = &temp2;
37921 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37922 }
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 (arg1)->SetSpacer((wxSize const &)*arg2);
37926
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 Py_INCREF(Py_None); resultobj = Py_None;
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj;
37939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37940 bool arg2 ;
37941 PyObject * obj0 = 0 ;
37942 PyObject * obj1 = 0 ;
37943 char *kwnames[] = {
37944 (char *) "self",(char *) "show", NULL
37945 };
37946
37947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
37948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37949 if (SWIG_arg_fail(1)) SWIG_fail;
37950 {
37951 arg2 = (bool)(SWIG_As_bool(obj1));
37952 if (SWIG_arg_fail(2)) SWIG_fail;
37953 }
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 (arg1)->Show(arg2);
37957
37958 wxPyEndAllowThreads(__tstate);
37959 if (PyErr_Occurred()) SWIG_fail;
37960 }
37961 Py_INCREF(Py_None); resultobj = Py_None;
37962 return resultobj;
37963 fail:
37964 return NULL;
37965 }
37966
37967
37968 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj;
37970 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37971 bool result;
37972 PyObject * obj0 = 0 ;
37973 char *kwnames[] = {
37974 (char *) "self", NULL
37975 };
37976
37977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
37978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37979 if (SWIG_arg_fail(1)) SWIG_fail;
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 result = (bool)(arg1)->IsShown();
37983
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 {
37988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37989 }
37990 return resultobj;
37991 fail:
37992 return NULL;
37993 }
37994
37995
37996 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
37997 PyObject *resultobj;
37998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37999 wxPoint result;
38000 PyObject * obj0 = 0 ;
38001 char *kwnames[] = {
38002 (char *) "self", NULL
38003 };
38004
38005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38007 if (SWIG_arg_fail(1)) SWIG_fail;
38008 {
38009 PyThreadState* __tstate = wxPyBeginAllowThreads();
38010 result = (arg1)->GetPosition();
38011
38012 wxPyEndAllowThreads(__tstate);
38013 if (PyErr_Occurred()) SWIG_fail;
38014 }
38015 {
38016 wxPoint * resultptr;
38017 resultptr = new wxPoint((wxPoint &)(result));
38018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38019 }
38020 return resultobj;
38021 fail:
38022 return NULL;
38023 }
38024
38025
38026 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38027 PyObject *resultobj;
38028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38029 PyObject *result;
38030 PyObject * obj0 = 0 ;
38031 char *kwnames[] = {
38032 (char *) "self", NULL
38033 };
38034
38035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38037 if (SWIG_arg_fail(1)) SWIG_fail;
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38041
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 resultobj = result;
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38053 PyObject *obj;
38054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38055 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38056 Py_INCREF(obj);
38057 return Py_BuildValue((char *)"");
38058 }
38059 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38060 PyObject *resultobj;
38061 wxSizer *arg1 = (wxSizer *) 0 ;
38062 PyObject *arg2 = (PyObject *) 0 ;
38063 PyObject * obj0 = 0 ;
38064 PyObject * obj1 = 0 ;
38065 char *kwnames[] = {
38066 (char *) "self",(char *) "_self", NULL
38067 };
38068
38069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38071 if (SWIG_arg_fail(1)) SWIG_fail;
38072 arg2 = obj1;
38073 {
38074 PyThreadState* __tstate = wxPyBeginAllowThreads();
38075 wxSizer__setOORInfo(arg1,arg2);
38076
38077 wxPyEndAllowThreads(__tstate);
38078 if (PyErr_Occurred()) SWIG_fail;
38079 }
38080 Py_INCREF(Py_None); resultobj = Py_None;
38081 return resultobj;
38082 fail:
38083 return NULL;
38084 }
38085
38086
38087 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38088 PyObject *resultobj;
38089 wxSizer *arg1 = (wxSizer *) 0 ;
38090 PyObject *arg2 = (PyObject *) 0 ;
38091 int arg3 = (int) 0 ;
38092 int arg4 = (int) 0 ;
38093 int arg5 = (int) 0 ;
38094 PyObject *arg6 = (PyObject *) NULL ;
38095 wxSizerItem *result;
38096 PyObject * obj0 = 0 ;
38097 PyObject * obj1 = 0 ;
38098 PyObject * obj2 = 0 ;
38099 PyObject * obj3 = 0 ;
38100 PyObject * obj4 = 0 ;
38101 PyObject * obj5 = 0 ;
38102 char *kwnames[] = {
38103 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38104 };
38105
38106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38108 if (SWIG_arg_fail(1)) SWIG_fail;
38109 arg2 = obj1;
38110 if (obj2) {
38111 {
38112 arg3 = (int)(SWIG_As_int(obj2));
38113 if (SWIG_arg_fail(3)) SWIG_fail;
38114 }
38115 }
38116 if (obj3) {
38117 {
38118 arg4 = (int)(SWIG_As_int(obj3));
38119 if (SWIG_arg_fail(4)) SWIG_fail;
38120 }
38121 }
38122 if (obj4) {
38123 {
38124 arg5 = (int)(SWIG_As_int(obj4));
38125 if (SWIG_arg_fail(5)) SWIG_fail;
38126 }
38127 }
38128 if (obj5) {
38129 arg6 = obj5;
38130 }
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38134
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj;
38147 wxSizer *arg1 = (wxSizer *) 0 ;
38148 int arg2 ;
38149 PyObject *arg3 = (PyObject *) 0 ;
38150 int arg4 = (int) 0 ;
38151 int arg5 = (int) 0 ;
38152 int arg6 = (int) 0 ;
38153 PyObject *arg7 = (PyObject *) NULL ;
38154 wxSizerItem *result;
38155 PyObject * obj0 = 0 ;
38156 PyObject * obj1 = 0 ;
38157 PyObject * obj2 = 0 ;
38158 PyObject * obj3 = 0 ;
38159 PyObject * obj4 = 0 ;
38160 PyObject * obj5 = 0 ;
38161 PyObject * obj6 = 0 ;
38162 char *kwnames[] = {
38163 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38164 };
38165
38166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, 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 arg3 = obj2;
38174 if (obj3) {
38175 {
38176 arg4 = (int)(SWIG_As_int(obj3));
38177 if (SWIG_arg_fail(4)) SWIG_fail;
38178 }
38179 }
38180 if (obj4) {
38181 {
38182 arg5 = (int)(SWIG_As_int(obj4));
38183 if (SWIG_arg_fail(5)) SWIG_fail;
38184 }
38185 }
38186 if (obj5) {
38187 {
38188 arg6 = (int)(SWIG_As_int(obj5));
38189 if (SWIG_arg_fail(6)) SWIG_fail;
38190 }
38191 }
38192 if (obj6) {
38193 arg7 = obj6;
38194 }
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38198
38199 wxPyEndAllowThreads(__tstate);
38200 if (PyErr_Occurred()) SWIG_fail;
38201 }
38202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38203 return resultobj;
38204 fail:
38205 return NULL;
38206 }
38207
38208
38209 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38210 PyObject *resultobj;
38211 wxSizer *arg1 = (wxSizer *) 0 ;
38212 PyObject *arg2 = (PyObject *) 0 ;
38213 int arg3 = (int) 0 ;
38214 int arg4 = (int) 0 ;
38215 int arg5 = (int) 0 ;
38216 PyObject *arg6 = (PyObject *) NULL ;
38217 wxSizerItem *result;
38218 PyObject * obj0 = 0 ;
38219 PyObject * obj1 = 0 ;
38220 PyObject * obj2 = 0 ;
38221 PyObject * obj3 = 0 ;
38222 PyObject * obj4 = 0 ;
38223 PyObject * obj5 = 0 ;
38224 char *kwnames[] = {
38225 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38226 };
38227
38228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38230 if (SWIG_arg_fail(1)) SWIG_fail;
38231 arg2 = obj1;
38232 if (obj2) {
38233 {
38234 arg3 = (int)(SWIG_As_int(obj2));
38235 if (SWIG_arg_fail(3)) SWIG_fail;
38236 }
38237 }
38238 if (obj3) {
38239 {
38240 arg4 = (int)(SWIG_As_int(obj3));
38241 if (SWIG_arg_fail(4)) SWIG_fail;
38242 }
38243 }
38244 if (obj4) {
38245 {
38246 arg5 = (int)(SWIG_As_int(obj4));
38247 if (SWIG_arg_fail(5)) SWIG_fail;
38248 }
38249 }
38250 if (obj5) {
38251 arg6 = obj5;
38252 }
38253 {
38254 PyThreadState* __tstate = wxPyBeginAllowThreads();
38255 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38256
38257 wxPyEndAllowThreads(__tstate);
38258 if (PyErr_Occurred()) SWIG_fail;
38259 }
38260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38261 return resultobj;
38262 fail:
38263 return NULL;
38264 }
38265
38266
38267 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38268 PyObject *resultobj;
38269 wxSizer *arg1 = (wxSizer *) 0 ;
38270 PyObject *arg2 = (PyObject *) 0 ;
38271 bool result;
38272 PyObject * obj0 = 0 ;
38273 PyObject * obj1 = 0 ;
38274 char *kwnames[] = {
38275 (char *) "self",(char *) "item", NULL
38276 };
38277
38278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38280 if (SWIG_arg_fail(1)) SWIG_fail;
38281 arg2 = obj1;
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 result = (bool)wxSizer_Remove(arg1,arg2);
38285
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 {
38290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38291 }
38292 return resultobj;
38293 fail:
38294 return NULL;
38295 }
38296
38297
38298 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38299 PyObject *resultobj;
38300 wxSizer *arg1 = (wxSizer *) 0 ;
38301 PyObject *arg2 = (PyObject *) 0 ;
38302 bool result;
38303 PyObject * obj0 = 0 ;
38304 PyObject * obj1 = 0 ;
38305 char *kwnames[] = {
38306 (char *) "self",(char *) "item", NULL
38307 };
38308
38309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38311 if (SWIG_arg_fail(1)) SWIG_fail;
38312 arg2 = obj1;
38313 {
38314 PyThreadState* __tstate = wxPyBeginAllowThreads();
38315 result = (bool)wxSizer_Detach(arg1,arg2);
38316
38317 wxPyEndAllowThreads(__tstate);
38318 if (PyErr_Occurred()) SWIG_fail;
38319 }
38320 {
38321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38322 }
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj;
38331 wxSizer *arg1 = (wxSizer *) 0 ;
38332 PyObject *arg2 = (PyObject *) 0 ;
38333 wxSizerItem *result;
38334 PyObject * obj0 = 0 ;
38335 PyObject * obj1 = 0 ;
38336 char *kwnames[] = {
38337 (char *) "self",(char *) "item", NULL
38338 };
38339
38340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38342 if (SWIG_arg_fail(1)) SWIG_fail;
38343 arg2 = obj1;
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38347
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38359 PyObject *resultobj;
38360 wxSizer *arg1 = (wxSizer *) 0 ;
38361 PyObject *arg2 = (PyObject *) 0 ;
38362 wxSize *arg3 = 0 ;
38363 wxSize temp3 ;
38364 PyObject * obj0 = 0 ;
38365 PyObject * obj1 = 0 ;
38366 PyObject * obj2 = 0 ;
38367 char *kwnames[] = {
38368 (char *) "self",(char *) "item",(char *) "size", NULL
38369 };
38370
38371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38373 if (SWIG_arg_fail(1)) SWIG_fail;
38374 arg2 = obj1;
38375 {
38376 arg3 = &temp3;
38377 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38378 }
38379 {
38380 PyThreadState* __tstate = wxPyBeginAllowThreads();
38381 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38382
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 Py_INCREF(Py_None); resultobj = Py_None;
38387 return resultobj;
38388 fail:
38389 return NULL;
38390 }
38391
38392
38393 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38394 PyObject *resultobj;
38395 wxSizer *arg1 = (wxSizer *) 0 ;
38396 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38397 wxSizerItem *result;
38398 PyObject * obj0 = 0 ;
38399 PyObject * obj1 = 0 ;
38400 char *kwnames[] = {
38401 (char *) "self",(char *) "item", NULL
38402 };
38403
38404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38406 if (SWIG_arg_fail(1)) SWIG_fail;
38407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38408 if (SWIG_arg_fail(2)) SWIG_fail;
38409 {
38410 PyThreadState* __tstate = wxPyBeginAllowThreads();
38411 result = (wxSizerItem *)(arg1)->Add(arg2);
38412
38413 wxPyEndAllowThreads(__tstate);
38414 if (PyErr_Occurred()) SWIG_fail;
38415 }
38416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38417 return resultobj;
38418 fail:
38419 return NULL;
38420 }
38421
38422
38423 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38424 PyObject *resultobj;
38425 wxSizer *arg1 = (wxSizer *) 0 ;
38426 size_t arg2 ;
38427 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38428 wxSizerItem *result;
38429 PyObject * obj0 = 0 ;
38430 PyObject * obj1 = 0 ;
38431 PyObject * obj2 = 0 ;
38432 char *kwnames[] = {
38433 (char *) "self",(char *) "index",(char *) "item", NULL
38434 };
38435
38436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38438 if (SWIG_arg_fail(1)) SWIG_fail;
38439 {
38440 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38441 if (SWIG_arg_fail(2)) SWIG_fail;
38442 }
38443 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38444 if (SWIG_arg_fail(3)) SWIG_fail;
38445 {
38446 PyThreadState* __tstate = wxPyBeginAllowThreads();
38447 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38448
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38453 return resultobj;
38454 fail:
38455 return NULL;
38456 }
38457
38458
38459 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38460 PyObject *resultobj;
38461 wxSizer *arg1 = (wxSizer *) 0 ;
38462 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38463 wxSizerItem *result;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 char *kwnames[] = {
38467 (char *) "self",(char *) "item", NULL
38468 };
38469
38470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38472 if (SWIG_arg_fail(1)) SWIG_fail;
38473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38474 if (SWIG_arg_fail(2)) SWIG_fail;
38475 {
38476 PyThreadState* __tstate = wxPyBeginAllowThreads();
38477 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38478
38479 wxPyEndAllowThreads(__tstate);
38480 if (PyErr_Occurred()) SWIG_fail;
38481 }
38482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38483 return resultobj;
38484 fail:
38485 return NULL;
38486 }
38487
38488
38489 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38490 PyObject *resultobj;
38491 wxSizer *arg1 = (wxSizer *) 0 ;
38492 int arg2 ;
38493 int arg3 ;
38494 int arg4 ;
38495 int arg5 ;
38496 PyObject * obj0 = 0 ;
38497 PyObject * obj1 = 0 ;
38498 PyObject * obj2 = 0 ;
38499 PyObject * obj3 = 0 ;
38500 PyObject * obj4 = 0 ;
38501 char *kwnames[] = {
38502 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38503 };
38504
38505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38507 if (SWIG_arg_fail(1)) SWIG_fail;
38508 {
38509 arg2 = (int)(SWIG_As_int(obj1));
38510 if (SWIG_arg_fail(2)) SWIG_fail;
38511 }
38512 {
38513 arg3 = (int)(SWIG_As_int(obj2));
38514 if (SWIG_arg_fail(3)) SWIG_fail;
38515 }
38516 {
38517 arg4 = (int)(SWIG_As_int(obj3));
38518 if (SWIG_arg_fail(4)) SWIG_fail;
38519 }
38520 {
38521 arg5 = (int)(SWIG_As_int(obj4));
38522 if (SWIG_arg_fail(5)) SWIG_fail;
38523 }
38524 {
38525 PyThreadState* __tstate = wxPyBeginAllowThreads();
38526 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38527
38528 wxPyEndAllowThreads(__tstate);
38529 if (PyErr_Occurred()) SWIG_fail;
38530 }
38531 Py_INCREF(Py_None); resultobj = Py_None;
38532 return resultobj;
38533 fail:
38534 return NULL;
38535 }
38536
38537
38538 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38539 PyObject *resultobj;
38540 wxSizer *arg1 = (wxSizer *) 0 ;
38541 wxSize *arg2 = 0 ;
38542 wxSize temp2 ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 char *kwnames[] = {
38546 (char *) "self",(char *) "size", NULL
38547 };
38548
38549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38551 if (SWIG_arg_fail(1)) SWIG_fail;
38552 {
38553 arg2 = &temp2;
38554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38555 }
38556 {
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 (arg1)->SetMinSize((wxSize const &)*arg2);
38559
38560 wxPyEndAllowThreads(__tstate);
38561 if (PyErr_Occurred()) SWIG_fail;
38562 }
38563 Py_INCREF(Py_None); resultobj = Py_None;
38564 return resultobj;
38565 fail:
38566 return NULL;
38567 }
38568
38569
38570 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38571 PyObject *resultobj;
38572 wxSizer *arg1 = (wxSizer *) 0 ;
38573 wxSize result;
38574 PyObject * obj0 = 0 ;
38575 char *kwnames[] = {
38576 (char *) "self", NULL
38577 };
38578
38579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38581 if (SWIG_arg_fail(1)) SWIG_fail;
38582 {
38583 PyThreadState* __tstate = wxPyBeginAllowThreads();
38584 result = (arg1)->GetSize();
38585
38586 wxPyEndAllowThreads(__tstate);
38587 if (PyErr_Occurred()) SWIG_fail;
38588 }
38589 {
38590 wxSize * resultptr;
38591 resultptr = new wxSize((wxSize &)(result));
38592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38593 }
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38601 PyObject *resultobj;
38602 wxSizer *arg1 = (wxSizer *) 0 ;
38603 wxPoint result;
38604 PyObject * obj0 = 0 ;
38605 char *kwnames[] = {
38606 (char *) "self", NULL
38607 };
38608
38609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38611 if (SWIG_arg_fail(1)) SWIG_fail;
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (arg1)->GetPosition();
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 {
38620 wxPoint * resultptr;
38621 resultptr = new wxPoint((wxPoint &)(result));
38622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38623 }
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj;
38632 wxSizer *arg1 = (wxSizer *) 0 ;
38633 wxSize result;
38634 PyObject * obj0 = 0 ;
38635 char *kwnames[] = {
38636 (char *) "self", NULL
38637 };
38638
38639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38641 if (SWIG_arg_fail(1)) SWIG_fail;
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (arg1)->GetMinSize();
38645
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 {
38650 wxSize * resultptr;
38651 resultptr = new wxSize((wxSize &)(result));
38652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38653 }
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj;
38662 wxSizer *arg1 = (wxSizer *) 0 ;
38663 PyObject * obj0 = 0 ;
38664 char *kwnames[] = {
38665 (char *) "self", NULL
38666 };
38667
38668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38670 if (SWIG_arg_fail(1)) SWIG_fail;
38671 {
38672 PyThreadState* __tstate = wxPyBeginAllowThreads();
38673 (arg1)->RecalcSizes();
38674
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 Py_INCREF(Py_None); resultobj = Py_None;
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj;
38687 wxSizer *arg1 = (wxSizer *) 0 ;
38688 wxSize result;
38689 PyObject * obj0 = 0 ;
38690 char *kwnames[] = {
38691 (char *) "self", NULL
38692 };
38693
38694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38696 if (SWIG_arg_fail(1)) SWIG_fail;
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (arg1)->CalcMin();
38700
38701 wxPyEndAllowThreads(__tstate);
38702 if (PyErr_Occurred()) SWIG_fail;
38703 }
38704 {
38705 wxSize * resultptr;
38706 resultptr = new wxSize((wxSize &)(result));
38707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38708 }
38709 return resultobj;
38710 fail:
38711 return NULL;
38712 }
38713
38714
38715 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38716 PyObject *resultobj;
38717 wxSizer *arg1 = (wxSizer *) 0 ;
38718 PyObject * obj0 = 0 ;
38719 char *kwnames[] = {
38720 (char *) "self", NULL
38721 };
38722
38723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38725 if (SWIG_arg_fail(1)) SWIG_fail;
38726 {
38727 PyThreadState* __tstate = wxPyBeginAllowThreads();
38728 (arg1)->Layout();
38729
38730 wxPyEndAllowThreads(__tstate);
38731 if (PyErr_Occurred()) SWIG_fail;
38732 }
38733 Py_INCREF(Py_None); resultobj = Py_None;
38734 return resultobj;
38735 fail:
38736 return NULL;
38737 }
38738
38739
38740 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38741 PyObject *resultobj;
38742 wxSizer *arg1 = (wxSizer *) 0 ;
38743 wxWindow *arg2 = (wxWindow *) 0 ;
38744 wxSize result;
38745 PyObject * obj0 = 0 ;
38746 PyObject * obj1 = 0 ;
38747 char *kwnames[] = {
38748 (char *) "self",(char *) "window", NULL
38749 };
38750
38751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38753 if (SWIG_arg_fail(1)) SWIG_fail;
38754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38755 if (SWIG_arg_fail(2)) SWIG_fail;
38756 {
38757 PyThreadState* __tstate = wxPyBeginAllowThreads();
38758 result = (arg1)->Fit(arg2);
38759
38760 wxPyEndAllowThreads(__tstate);
38761 if (PyErr_Occurred()) SWIG_fail;
38762 }
38763 {
38764 wxSize * resultptr;
38765 resultptr = new wxSize((wxSize &)(result));
38766 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38767 }
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38775 PyObject *resultobj;
38776 wxSizer *arg1 = (wxSizer *) 0 ;
38777 wxWindow *arg2 = (wxWindow *) 0 ;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 char *kwnames[] = {
38781 (char *) "self",(char *) "window", NULL
38782 };
38783
38784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38786 if (SWIG_arg_fail(1)) SWIG_fail;
38787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38788 if (SWIG_arg_fail(2)) SWIG_fail;
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 (arg1)->FitInside(arg2);
38792
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 Py_INCREF(Py_None); resultobj = Py_None;
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj;
38805 wxSizer *arg1 = (wxSizer *) 0 ;
38806 wxWindow *arg2 = (wxWindow *) 0 ;
38807 PyObject * obj0 = 0 ;
38808 PyObject * obj1 = 0 ;
38809 char *kwnames[] = {
38810 (char *) "self",(char *) "window", NULL
38811 };
38812
38813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
38814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38815 if (SWIG_arg_fail(1)) SWIG_fail;
38816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38817 if (SWIG_arg_fail(2)) SWIG_fail;
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 (arg1)->SetSizeHints(arg2);
38821
38822 wxPyEndAllowThreads(__tstate);
38823 if (PyErr_Occurred()) SWIG_fail;
38824 }
38825 Py_INCREF(Py_None); resultobj = Py_None;
38826 return resultobj;
38827 fail:
38828 return NULL;
38829 }
38830
38831
38832 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38833 PyObject *resultobj;
38834 wxSizer *arg1 = (wxSizer *) 0 ;
38835 wxWindow *arg2 = (wxWindow *) 0 ;
38836 PyObject * obj0 = 0 ;
38837 PyObject * obj1 = 0 ;
38838 char *kwnames[] = {
38839 (char *) "self",(char *) "window", NULL
38840 };
38841
38842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
38843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38844 if (SWIG_arg_fail(1)) SWIG_fail;
38845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38846 if (SWIG_arg_fail(2)) SWIG_fail;
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 (arg1)->SetVirtualSizeHints(arg2);
38850
38851 wxPyEndAllowThreads(__tstate);
38852 if (PyErr_Occurred()) SWIG_fail;
38853 }
38854 Py_INCREF(Py_None); resultobj = Py_None;
38855 return resultobj;
38856 fail:
38857 return NULL;
38858 }
38859
38860
38861 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38862 PyObject *resultobj;
38863 wxSizer *arg1 = (wxSizer *) 0 ;
38864 bool arg2 = (bool) false ;
38865 PyObject * obj0 = 0 ;
38866 PyObject * obj1 = 0 ;
38867 char *kwnames[] = {
38868 (char *) "self",(char *) "deleteWindows", NULL
38869 };
38870
38871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
38872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38873 if (SWIG_arg_fail(1)) SWIG_fail;
38874 if (obj1) {
38875 {
38876 arg2 = (bool)(SWIG_As_bool(obj1));
38877 if (SWIG_arg_fail(2)) SWIG_fail;
38878 }
38879 }
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 (arg1)->Clear(arg2);
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_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj;
38896 wxSizer *arg1 = (wxSizer *) 0 ;
38897 PyObject * obj0 = 0 ;
38898 char *kwnames[] = {
38899 (char *) "self", NULL
38900 };
38901
38902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
38903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38904 if (SWIG_arg_fail(1)) SWIG_fail;
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 (arg1)->DeleteWindows();
38908
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 Py_INCREF(Py_None); resultobj = Py_None;
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj;
38921 wxSizer *arg1 = (wxSizer *) 0 ;
38922 PyObject *result;
38923 PyObject * obj0 = 0 ;
38924 char *kwnames[] = {
38925 (char *) "self", NULL
38926 };
38927
38928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
38929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38930 if (SWIG_arg_fail(1)) SWIG_fail;
38931 {
38932 PyThreadState* __tstate = wxPyBeginAllowThreads();
38933 result = (PyObject *)wxSizer_GetChildren(arg1);
38934
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 resultobj = result;
38939 return resultobj;
38940 fail:
38941 return NULL;
38942 }
38943
38944
38945 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38946 PyObject *resultobj;
38947 wxSizer *arg1 = (wxSizer *) 0 ;
38948 PyObject *arg2 = (PyObject *) 0 ;
38949 bool arg3 = (bool) true ;
38950 bool arg4 = (bool) false ;
38951 bool result;
38952 PyObject * obj0 = 0 ;
38953 PyObject * obj1 = 0 ;
38954 PyObject * obj2 = 0 ;
38955 PyObject * obj3 = 0 ;
38956 char *kwnames[] = {
38957 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
38958 };
38959
38960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38962 if (SWIG_arg_fail(1)) SWIG_fail;
38963 arg2 = obj1;
38964 if (obj2) {
38965 {
38966 arg3 = (bool)(SWIG_As_bool(obj2));
38967 if (SWIG_arg_fail(3)) SWIG_fail;
38968 }
38969 }
38970 if (obj3) {
38971 {
38972 arg4 = (bool)(SWIG_As_bool(obj3));
38973 if (SWIG_arg_fail(4)) SWIG_fail;
38974 }
38975 }
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizer *arg1 = (wxSizer *) 0 ;
38995 PyObject *arg2 = (PyObject *) 0 ;
38996 bool result;
38997 PyObject * obj0 = 0 ;
38998 PyObject * obj1 = 0 ;
38999 char *kwnames[] = {
39000 (char *) "self",(char *) "item", NULL
39001 };
39002
39003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39005 if (SWIG_arg_fail(1)) SWIG_fail;
39006 arg2 = obj1;
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 result = (bool)wxSizer_IsShown(arg1,arg2);
39010
39011 wxPyEndAllowThreads(__tstate);
39012 if (PyErr_Occurred()) SWIG_fail;
39013 }
39014 {
39015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39016 }
39017 return resultobj;
39018 fail:
39019 return NULL;
39020 }
39021
39022
39023 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39024 PyObject *resultobj;
39025 wxSizer *arg1 = (wxSizer *) 0 ;
39026 bool arg2 ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char *kwnames[] = {
39030 (char *) "self",(char *) "show", NULL
39031 };
39032
39033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39035 if (SWIG_arg_fail(1)) SWIG_fail;
39036 {
39037 arg2 = (bool)(SWIG_As_bool(obj1));
39038 if (SWIG_arg_fail(2)) SWIG_fail;
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 (arg1)->ShowItems(arg2);
39043
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 Py_INCREF(Py_None); resultobj = Py_None;
39048 return resultobj;
39049 fail:
39050 return NULL;
39051 }
39052
39053
39054 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39055 PyObject *obj;
39056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39057 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39058 Py_INCREF(obj);
39059 return Py_BuildValue((char *)"");
39060 }
39061 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39062 PyObject *resultobj;
39063 wxPySizer *result;
39064 char *kwnames[] = {
39065 NULL
39066 };
39067
39068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (wxPySizer *)new wxPySizer();
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj;
39085 wxPySizer *arg1 = (wxPySizer *) 0 ;
39086 PyObject *arg2 = (PyObject *) 0 ;
39087 PyObject *arg3 = (PyObject *) 0 ;
39088 PyObject * obj0 = 0 ;
39089 PyObject * obj1 = 0 ;
39090 PyObject * obj2 = 0 ;
39091 char *kwnames[] = {
39092 (char *) "self",(char *) "self",(char *) "_class", NULL
39093 };
39094
39095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39097 if (SWIG_arg_fail(1)) SWIG_fail;
39098 arg2 = obj1;
39099 arg3 = obj2;
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 (arg1)->_setCallbackInfo(arg2,arg3);
39103
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 Py_INCREF(Py_None); resultobj = Py_None;
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39115 PyObject *obj;
39116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39117 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39118 Py_INCREF(obj);
39119 return Py_BuildValue((char *)"");
39120 }
39121 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj;
39123 int arg1 = (int) wxHORIZONTAL ;
39124 wxBoxSizer *result;
39125 PyObject * obj0 = 0 ;
39126 char *kwnames[] = {
39127 (char *) "orient", NULL
39128 };
39129
39130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39131 if (obj0) {
39132 {
39133 arg1 = (int)(SWIG_As_int(obj0));
39134 if (SWIG_arg_fail(1)) SWIG_fail;
39135 }
39136 }
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39140
39141 wxPyEndAllowThreads(__tstate);
39142 if (PyErr_Occurred()) SWIG_fail;
39143 }
39144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj;
39153 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39154 int result;
39155 PyObject * obj0 = 0 ;
39156 char *kwnames[] = {
39157 (char *) "self", NULL
39158 };
39159
39160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39162 if (SWIG_arg_fail(1)) SWIG_fail;
39163 {
39164 PyThreadState* __tstate = wxPyBeginAllowThreads();
39165 result = (int)(arg1)->GetOrientation();
39166
39167 wxPyEndAllowThreads(__tstate);
39168 if (PyErr_Occurred()) SWIG_fail;
39169 }
39170 {
39171 resultobj = SWIG_From_int((int)(result));
39172 }
39173 return resultobj;
39174 fail:
39175 return NULL;
39176 }
39177
39178
39179 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39180 PyObject *resultobj;
39181 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39182 int arg2 ;
39183 PyObject * obj0 = 0 ;
39184 PyObject * obj1 = 0 ;
39185 char *kwnames[] = {
39186 (char *) "self",(char *) "orient", NULL
39187 };
39188
39189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39191 if (SWIG_arg_fail(1)) SWIG_fail;
39192 {
39193 arg2 = (int)(SWIG_As_int(obj1));
39194 if (SWIG_arg_fail(2)) SWIG_fail;
39195 }
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 (arg1)->SetOrientation(arg2);
39199
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 Py_INCREF(Py_None); resultobj = Py_None;
39204 return resultobj;
39205 fail:
39206 return NULL;
39207 }
39208
39209
39210 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39211 PyObject *obj;
39212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39213 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39214 Py_INCREF(obj);
39215 return Py_BuildValue((char *)"");
39216 }
39217 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj;
39219 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39220 int arg2 = (int) wxHORIZONTAL ;
39221 wxStaticBoxSizer *result;
39222 PyObject * obj0 = 0 ;
39223 PyObject * obj1 = 0 ;
39224 char *kwnames[] = {
39225 (char *) "box",(char *) "orient", NULL
39226 };
39227
39228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39230 if (SWIG_arg_fail(1)) SWIG_fail;
39231 if (obj1) {
39232 {
39233 arg2 = (int)(SWIG_As_int(obj1));
39234 if (SWIG_arg_fail(2)) SWIG_fail;
39235 }
39236 }
39237 {
39238 PyThreadState* __tstate = wxPyBeginAllowThreads();
39239 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39240
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj;
39253 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39254 wxStaticBox *result;
39255 PyObject * obj0 = 0 ;
39256 char *kwnames[] = {
39257 (char *) "self", NULL
39258 };
39259
39260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39262 if (SWIG_arg_fail(1)) SWIG_fail;
39263 {
39264 PyThreadState* __tstate = wxPyBeginAllowThreads();
39265 result = (wxStaticBox *)(arg1)->GetStaticBox();
39266
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = wxPyMake_wxObject(result, 0);
39272 }
39273 return resultobj;
39274 fail:
39275 return NULL;
39276 }
39277
39278
39279 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39280 PyObject *obj;
39281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39282 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39283 Py_INCREF(obj);
39284 return Py_BuildValue((char *)"");
39285 }
39286 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39287 PyObject *resultobj;
39288 int arg1 = (int) 1 ;
39289 int arg2 = (int) 0 ;
39290 int arg3 = (int) 0 ;
39291 int arg4 = (int) 0 ;
39292 wxGridSizer *result;
39293 PyObject * obj0 = 0 ;
39294 PyObject * obj1 = 0 ;
39295 PyObject * obj2 = 0 ;
39296 PyObject * obj3 = 0 ;
39297 char *kwnames[] = {
39298 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39299 };
39300
39301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39302 if (obj0) {
39303 {
39304 arg1 = (int)(SWIG_As_int(obj0));
39305 if (SWIG_arg_fail(1)) SWIG_fail;
39306 }
39307 }
39308 if (obj1) {
39309 {
39310 arg2 = (int)(SWIG_As_int(obj1));
39311 if (SWIG_arg_fail(2)) SWIG_fail;
39312 }
39313 }
39314 if (obj2) {
39315 {
39316 arg3 = (int)(SWIG_As_int(obj2));
39317 if (SWIG_arg_fail(3)) SWIG_fail;
39318 }
39319 }
39320 if (obj3) {
39321 {
39322 arg4 = (int)(SWIG_As_int(obj3));
39323 if (SWIG_arg_fail(4)) SWIG_fail;
39324 }
39325 }
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj;
39342 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39343 int arg2 ;
39344 PyObject * obj0 = 0 ;
39345 PyObject * obj1 = 0 ;
39346 char *kwnames[] = {
39347 (char *) "self",(char *) "cols", NULL
39348 };
39349
39350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39352 if (SWIG_arg_fail(1)) SWIG_fail;
39353 {
39354 arg2 = (int)(SWIG_As_int(obj1));
39355 if (SWIG_arg_fail(2)) SWIG_fail;
39356 }
39357 {
39358 PyThreadState* __tstate = wxPyBeginAllowThreads();
39359 (arg1)->SetCols(arg2);
39360
39361 wxPyEndAllowThreads(__tstate);
39362 if (PyErr_Occurred()) SWIG_fail;
39363 }
39364 Py_INCREF(Py_None); resultobj = Py_None;
39365 return resultobj;
39366 fail:
39367 return NULL;
39368 }
39369
39370
39371 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39372 PyObject *resultobj;
39373 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39374 int arg2 ;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 char *kwnames[] = {
39378 (char *) "self",(char *) "rows", NULL
39379 };
39380
39381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39383 if (SWIG_arg_fail(1)) SWIG_fail;
39384 {
39385 arg2 = (int)(SWIG_As_int(obj1));
39386 if (SWIG_arg_fail(2)) SWIG_fail;
39387 }
39388 {
39389 PyThreadState* __tstate = wxPyBeginAllowThreads();
39390 (arg1)->SetRows(arg2);
39391
39392 wxPyEndAllowThreads(__tstate);
39393 if (PyErr_Occurred()) SWIG_fail;
39394 }
39395 Py_INCREF(Py_None); resultobj = Py_None;
39396 return resultobj;
39397 fail:
39398 return NULL;
39399 }
39400
39401
39402 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39403 PyObject *resultobj;
39404 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39405 int arg2 ;
39406 PyObject * obj0 = 0 ;
39407 PyObject * obj1 = 0 ;
39408 char *kwnames[] = {
39409 (char *) "self",(char *) "gap", NULL
39410 };
39411
39412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39414 if (SWIG_arg_fail(1)) SWIG_fail;
39415 {
39416 arg2 = (int)(SWIG_As_int(obj1));
39417 if (SWIG_arg_fail(2)) SWIG_fail;
39418 }
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 (arg1)->SetVGap(arg2);
39422
39423 wxPyEndAllowThreads(__tstate);
39424 if (PyErr_Occurred()) SWIG_fail;
39425 }
39426 Py_INCREF(Py_None); resultobj = Py_None;
39427 return resultobj;
39428 fail:
39429 return NULL;
39430 }
39431
39432
39433 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39434 PyObject *resultobj;
39435 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39436 int arg2 ;
39437 PyObject * obj0 = 0 ;
39438 PyObject * obj1 = 0 ;
39439 char *kwnames[] = {
39440 (char *) "self",(char *) "gap", NULL
39441 };
39442
39443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39445 if (SWIG_arg_fail(1)) SWIG_fail;
39446 {
39447 arg2 = (int)(SWIG_As_int(obj1));
39448 if (SWIG_arg_fail(2)) SWIG_fail;
39449 }
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 (arg1)->SetHGap(arg2);
39453
39454 wxPyEndAllowThreads(__tstate);
39455 if (PyErr_Occurred()) SWIG_fail;
39456 }
39457 Py_INCREF(Py_None); resultobj = Py_None;
39458 return resultobj;
39459 fail:
39460 return NULL;
39461 }
39462
39463
39464 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39465 PyObject *resultobj;
39466 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39467 int result;
39468 PyObject * obj0 = 0 ;
39469 char *kwnames[] = {
39470 (char *) "self", NULL
39471 };
39472
39473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39475 if (SWIG_arg_fail(1)) SWIG_fail;
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 result = (int)(arg1)->GetCols();
39479
39480 wxPyEndAllowThreads(__tstate);
39481 if (PyErr_Occurred()) SWIG_fail;
39482 }
39483 {
39484 resultobj = SWIG_From_int((int)(result));
39485 }
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj;
39494 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39495 int result;
39496 PyObject * obj0 = 0 ;
39497 char *kwnames[] = {
39498 (char *) "self", NULL
39499 };
39500
39501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39503 if (SWIG_arg_fail(1)) SWIG_fail;
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 result = (int)(arg1)->GetRows();
39507
39508 wxPyEndAllowThreads(__tstate);
39509 if (PyErr_Occurred()) SWIG_fail;
39510 }
39511 {
39512 resultobj = SWIG_From_int((int)(result));
39513 }
39514 return resultobj;
39515 fail:
39516 return NULL;
39517 }
39518
39519
39520 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39521 PyObject *resultobj;
39522 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39523 int result;
39524 PyObject * obj0 = 0 ;
39525 char *kwnames[] = {
39526 (char *) "self", NULL
39527 };
39528
39529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39531 if (SWIG_arg_fail(1)) SWIG_fail;
39532 {
39533 PyThreadState* __tstate = wxPyBeginAllowThreads();
39534 result = (int)(arg1)->GetVGap();
39535
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 {
39540 resultobj = SWIG_From_int((int)(result));
39541 }
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj;
39550 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39551 int result;
39552 PyObject * obj0 = 0 ;
39553 char *kwnames[] = {
39554 (char *) "self", NULL
39555 };
39556
39557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39559 if (SWIG_arg_fail(1)) SWIG_fail;
39560 {
39561 PyThreadState* __tstate = wxPyBeginAllowThreads();
39562 result = (int)(arg1)->GetHGap();
39563
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = SWIG_From_int((int)(result));
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39577 PyObject *obj;
39578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39579 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39580 Py_INCREF(obj);
39581 return Py_BuildValue((char *)"");
39582 }
39583 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39584 PyObject *resultobj;
39585 int arg1 = (int) 1 ;
39586 int arg2 = (int) 0 ;
39587 int arg3 = (int) 0 ;
39588 int arg4 = (int) 0 ;
39589 wxFlexGridSizer *result;
39590 PyObject * obj0 = 0 ;
39591 PyObject * obj1 = 0 ;
39592 PyObject * obj2 = 0 ;
39593 PyObject * obj3 = 0 ;
39594 char *kwnames[] = {
39595 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39596 };
39597
39598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39599 if (obj0) {
39600 {
39601 arg1 = (int)(SWIG_As_int(obj0));
39602 if (SWIG_arg_fail(1)) SWIG_fail;
39603 }
39604 }
39605 if (obj1) {
39606 {
39607 arg2 = (int)(SWIG_As_int(obj1));
39608 if (SWIG_arg_fail(2)) SWIG_fail;
39609 }
39610 }
39611 if (obj2) {
39612 {
39613 arg3 = (int)(SWIG_As_int(obj2));
39614 if (SWIG_arg_fail(3)) SWIG_fail;
39615 }
39616 }
39617 if (obj3) {
39618 {
39619 arg4 = (int)(SWIG_As_int(obj3));
39620 if (SWIG_arg_fail(4)) SWIG_fail;
39621 }
39622 }
39623 {
39624 PyThreadState* __tstate = wxPyBeginAllowThreads();
39625 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39626
39627 wxPyEndAllowThreads(__tstate);
39628 if (PyErr_Occurred()) SWIG_fail;
39629 }
39630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39631 return resultobj;
39632 fail:
39633 return NULL;
39634 }
39635
39636
39637 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39638 PyObject *resultobj;
39639 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39640 size_t arg2 ;
39641 int arg3 = (int) 0 ;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 PyObject * obj2 = 0 ;
39645 char *kwnames[] = {
39646 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39647 };
39648
39649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39651 if (SWIG_arg_fail(1)) SWIG_fail;
39652 {
39653 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39654 if (SWIG_arg_fail(2)) SWIG_fail;
39655 }
39656 if (obj2) {
39657 {
39658 arg3 = (int)(SWIG_As_int(obj2));
39659 if (SWIG_arg_fail(3)) SWIG_fail;
39660 }
39661 }
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 (arg1)->AddGrowableRow(arg2,arg3);
39665
39666 wxPyEndAllowThreads(__tstate);
39667 if (PyErr_Occurred()) SWIG_fail;
39668 }
39669 Py_INCREF(Py_None); resultobj = Py_None;
39670 return resultobj;
39671 fail:
39672 return NULL;
39673 }
39674
39675
39676 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39677 PyObject *resultobj;
39678 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39679 size_t arg2 ;
39680 PyObject * obj0 = 0 ;
39681 PyObject * obj1 = 0 ;
39682 char *kwnames[] = {
39683 (char *) "self",(char *) "idx", NULL
39684 };
39685
39686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39688 if (SWIG_arg_fail(1)) SWIG_fail;
39689 {
39690 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39691 if (SWIG_arg_fail(2)) SWIG_fail;
39692 }
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 (arg1)->RemoveGrowableRow(arg2);
39696
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 Py_INCREF(Py_None); resultobj = Py_None;
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39708 PyObject *resultobj;
39709 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39710 size_t arg2 ;
39711 int arg3 = (int) 0 ;
39712 PyObject * obj0 = 0 ;
39713 PyObject * obj1 = 0 ;
39714 PyObject * obj2 = 0 ;
39715 char *kwnames[] = {
39716 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39717 };
39718
39719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(1)) SWIG_fail;
39722 {
39723 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39724 if (SWIG_arg_fail(2)) SWIG_fail;
39725 }
39726 if (obj2) {
39727 {
39728 arg3 = (int)(SWIG_As_int(obj2));
39729 if (SWIG_arg_fail(3)) SWIG_fail;
39730 }
39731 }
39732 {
39733 PyThreadState* __tstate = wxPyBeginAllowThreads();
39734 (arg1)->AddGrowableCol(arg2,arg3);
39735
39736 wxPyEndAllowThreads(__tstate);
39737 if (PyErr_Occurred()) SWIG_fail;
39738 }
39739 Py_INCREF(Py_None); resultobj = Py_None;
39740 return resultobj;
39741 fail:
39742 return NULL;
39743 }
39744
39745
39746 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39747 PyObject *resultobj;
39748 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39749 size_t arg2 ;
39750 PyObject * obj0 = 0 ;
39751 PyObject * obj1 = 0 ;
39752 char *kwnames[] = {
39753 (char *) "self",(char *) "idx", NULL
39754 };
39755
39756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39758 if (SWIG_arg_fail(1)) SWIG_fail;
39759 {
39760 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39761 if (SWIG_arg_fail(2)) SWIG_fail;
39762 }
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 (arg1)->RemoveGrowableCol(arg2);
39766
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 Py_INCREF(Py_None); resultobj = Py_None;
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj;
39779 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39780 int arg2 ;
39781 PyObject * obj0 = 0 ;
39782 PyObject * obj1 = 0 ;
39783 char *kwnames[] = {
39784 (char *) "self",(char *) "direction", NULL
39785 };
39786
39787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39789 if (SWIG_arg_fail(1)) SWIG_fail;
39790 {
39791 arg2 = (int)(SWIG_As_int(obj1));
39792 if (SWIG_arg_fail(2)) SWIG_fail;
39793 }
39794 {
39795 PyThreadState* __tstate = wxPyBeginAllowThreads();
39796 (arg1)->SetFlexibleDirection(arg2);
39797
39798 wxPyEndAllowThreads(__tstate);
39799 if (PyErr_Occurred()) SWIG_fail;
39800 }
39801 Py_INCREF(Py_None); resultobj = Py_None;
39802 return resultobj;
39803 fail:
39804 return NULL;
39805 }
39806
39807
39808 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39809 PyObject *resultobj;
39810 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39811 int result;
39812 PyObject * obj0 = 0 ;
39813 char *kwnames[] = {
39814 (char *) "self", NULL
39815 };
39816
39817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
39818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39819 if (SWIG_arg_fail(1)) SWIG_fail;
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 result = (int)(arg1)->GetFlexibleDirection();
39823
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 {
39828 resultobj = SWIG_From_int((int)(result));
39829 }
39830 return resultobj;
39831 fail:
39832 return NULL;
39833 }
39834
39835
39836 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39837 PyObject *resultobj;
39838 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39839 wxFlexSizerGrowMode arg2 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 char *kwnames[] = {
39843 (char *) "self",(char *) "mode", NULL
39844 };
39845
39846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
39847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39848 if (SWIG_arg_fail(1)) SWIG_fail;
39849 {
39850 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
39851 if (SWIG_arg_fail(2)) SWIG_fail;
39852 }
39853 {
39854 PyThreadState* __tstate = wxPyBeginAllowThreads();
39855 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
39856
39857 wxPyEndAllowThreads(__tstate);
39858 if (PyErr_Occurred()) SWIG_fail;
39859 }
39860 Py_INCREF(Py_None); resultobj = Py_None;
39861 return resultobj;
39862 fail:
39863 return NULL;
39864 }
39865
39866
39867 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39868 PyObject *resultobj;
39869 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39870 wxFlexSizerGrowMode result;
39871 PyObject * obj0 = 0 ;
39872 char *kwnames[] = {
39873 (char *) "self", NULL
39874 };
39875
39876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
39877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39878 if (SWIG_arg_fail(1)) SWIG_fail;
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
39882
39883 wxPyEndAllowThreads(__tstate);
39884 if (PyErr_Occurred()) SWIG_fail;
39885 }
39886 resultobj = SWIG_From_int((result));
39887 return resultobj;
39888 fail:
39889 return NULL;
39890 }
39891
39892
39893 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
39894 PyObject *resultobj;
39895 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39896 wxArrayInt *result;
39897 PyObject * obj0 = 0 ;
39898 char *kwnames[] = {
39899 (char *) "self", NULL
39900 };
39901
39902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
39903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39904 if (SWIG_arg_fail(1)) SWIG_fail;
39905 {
39906 PyThreadState* __tstate = wxPyBeginAllowThreads();
39907 {
39908 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
39909 result = (wxArrayInt *) &_result_ref;
39910 }
39911
39912 wxPyEndAllowThreads(__tstate);
39913 if (PyErr_Occurred()) SWIG_fail;
39914 }
39915 {
39916 resultobj = PyList_New(0);
39917 size_t idx;
39918 for (idx = 0; idx < result->GetCount(); idx += 1) {
39919 PyObject* val = PyInt_FromLong( result->Item(idx) );
39920 PyList_Append(resultobj, val);
39921 Py_DECREF(val);
39922 }
39923 }
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj;
39932 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39933 wxArrayInt *result;
39934 PyObject * obj0 = 0 ;
39935 char *kwnames[] = {
39936 (char *) "self", NULL
39937 };
39938
39939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
39940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39941 if (SWIG_arg_fail(1)) SWIG_fail;
39942 {
39943 PyThreadState* __tstate = wxPyBeginAllowThreads();
39944 {
39945 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
39946 result = (wxArrayInt *) &_result_ref;
39947 }
39948
39949 wxPyEndAllowThreads(__tstate);
39950 if (PyErr_Occurred()) SWIG_fail;
39951 }
39952 {
39953 resultobj = PyList_New(0);
39954 size_t idx;
39955 for (idx = 0; idx < result->GetCount(); idx += 1) {
39956 PyObject* val = PyInt_FromLong( result->Item(idx) );
39957 PyList_Append(resultobj, val);
39958 Py_DECREF(val);
39959 }
39960 }
39961 return resultobj;
39962 fail:
39963 return NULL;
39964 }
39965
39966
39967 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
39968 PyObject *obj;
39969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39970 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
39971 Py_INCREF(obj);
39972 return Py_BuildValue((char *)"");
39973 }
39974 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39975 PyObject *resultobj;
39976 wxStdDialogButtonSizer *result;
39977 char *kwnames[] = {
39978 NULL
39979 };
39980
39981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
39985
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj;
39998 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
39999 wxButton *arg2 = (wxButton *) 0 ;
40000 PyObject * obj0 = 0 ;
40001 PyObject * obj1 = 0 ;
40002 char *kwnames[] = {
40003 (char *) "self",(char *) "button", NULL
40004 };
40005
40006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40008 if (SWIG_arg_fail(1)) SWIG_fail;
40009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40010 if (SWIG_arg_fail(2)) SWIG_fail;
40011 {
40012 PyThreadState* __tstate = wxPyBeginAllowThreads();
40013 (arg1)->AddButton(arg2);
40014
40015 wxPyEndAllowThreads(__tstate);
40016 if (PyErr_Occurred()) SWIG_fail;
40017 }
40018 Py_INCREF(Py_None); resultobj = Py_None;
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj;
40027 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40028 PyObject * obj0 = 0 ;
40029 char *kwnames[] = {
40030 (char *) "self", NULL
40031 };
40032
40033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40035 if (SWIG_arg_fail(1)) SWIG_fail;
40036 {
40037 PyThreadState* __tstate = wxPyBeginAllowThreads();
40038 (arg1)->Finalise();
40039
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 Py_INCREF(Py_None); resultobj = Py_None;
40044 return resultobj;
40045 fail:
40046 return NULL;
40047 }
40048
40049
40050 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40051 PyObject *resultobj;
40052 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40053 wxButton *arg2 = (wxButton *) 0 ;
40054 PyObject * obj0 = 0 ;
40055 PyObject * obj1 = 0 ;
40056 char *kwnames[] = {
40057 (char *) "self",(char *) "button", NULL
40058 };
40059
40060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40062 if (SWIG_arg_fail(1)) SWIG_fail;
40063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40064 if (SWIG_arg_fail(2)) SWIG_fail;
40065 {
40066 PyThreadState* __tstate = wxPyBeginAllowThreads();
40067 (arg1)->SetAffirmativeButton(arg2);
40068
40069 wxPyEndAllowThreads(__tstate);
40070 if (PyErr_Occurred()) SWIG_fail;
40071 }
40072 Py_INCREF(Py_None); resultobj = Py_None;
40073 return resultobj;
40074 fail:
40075 return NULL;
40076 }
40077
40078
40079 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40080 PyObject *resultobj;
40081 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40082 wxButton *arg2 = (wxButton *) 0 ;
40083 PyObject * obj0 = 0 ;
40084 PyObject * obj1 = 0 ;
40085 char *kwnames[] = {
40086 (char *) "self",(char *) "button", NULL
40087 };
40088
40089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40091 if (SWIG_arg_fail(1)) SWIG_fail;
40092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(2)) SWIG_fail;
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 (arg1)->SetNegativeButton(arg2);
40097
40098 wxPyEndAllowThreads(__tstate);
40099 if (PyErr_Occurred()) SWIG_fail;
40100 }
40101 Py_INCREF(Py_None); resultobj = Py_None;
40102 return resultobj;
40103 fail:
40104 return NULL;
40105 }
40106
40107
40108 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40109 PyObject *resultobj;
40110 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40111 wxButton *arg2 = (wxButton *) 0 ;
40112 PyObject * obj0 = 0 ;
40113 PyObject * obj1 = 0 ;
40114 char *kwnames[] = {
40115 (char *) "self",(char *) "button", NULL
40116 };
40117
40118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40120 if (SWIG_arg_fail(1)) SWIG_fail;
40121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40122 if (SWIG_arg_fail(2)) SWIG_fail;
40123 {
40124 PyThreadState* __tstate = wxPyBeginAllowThreads();
40125 (arg1)->SetCancelButton(arg2);
40126
40127 wxPyEndAllowThreads(__tstate);
40128 if (PyErr_Occurred()) SWIG_fail;
40129 }
40130 Py_INCREF(Py_None); resultobj = Py_None;
40131 return resultobj;
40132 fail:
40133 return NULL;
40134 }
40135
40136
40137 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40138 PyObject *resultobj;
40139 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40140 wxButton *result;
40141 PyObject * obj0 = 0 ;
40142 char *kwnames[] = {
40143 (char *) "self", NULL
40144 };
40145
40146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40148 if (SWIG_arg_fail(1)) SWIG_fail;
40149 {
40150 PyThreadState* __tstate = wxPyBeginAllowThreads();
40151 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40152
40153 wxPyEndAllowThreads(__tstate);
40154 if (PyErr_Occurred()) SWIG_fail;
40155 }
40156 {
40157 resultobj = wxPyMake_wxObject(result, 0);
40158 }
40159 return resultobj;
40160 fail:
40161 return NULL;
40162 }
40163
40164
40165 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40166 PyObject *resultobj;
40167 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40168 wxButton *result;
40169 PyObject * obj0 = 0 ;
40170 char *kwnames[] = {
40171 (char *) "self", NULL
40172 };
40173
40174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40176 if (SWIG_arg_fail(1)) SWIG_fail;
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40180
40181 wxPyEndAllowThreads(__tstate);
40182 if (PyErr_Occurred()) SWIG_fail;
40183 }
40184 {
40185 resultobj = wxPyMake_wxObject(result, 0);
40186 }
40187 return resultobj;
40188 fail:
40189 return NULL;
40190 }
40191
40192
40193 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40194 PyObject *resultobj;
40195 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40196 wxButton *result;
40197 PyObject * obj0 = 0 ;
40198 char *kwnames[] = {
40199 (char *) "self", NULL
40200 };
40201
40202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40204 if (SWIG_arg_fail(1)) SWIG_fail;
40205 {
40206 PyThreadState* __tstate = wxPyBeginAllowThreads();
40207 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40208
40209 wxPyEndAllowThreads(__tstate);
40210 if (PyErr_Occurred()) SWIG_fail;
40211 }
40212 {
40213 resultobj = wxPyMake_wxObject(result, 0);
40214 }
40215 return resultobj;
40216 fail:
40217 return NULL;
40218 }
40219
40220
40221 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40222 PyObject *resultobj;
40223 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40224 wxButton *result;
40225 PyObject * obj0 = 0 ;
40226 char *kwnames[] = {
40227 (char *) "self", NULL
40228 };
40229
40230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40232 if (SWIG_arg_fail(1)) SWIG_fail;
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40236
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 {
40241 resultobj = wxPyMake_wxObject(result, 0);
40242 }
40243 return resultobj;
40244 fail:
40245 return NULL;
40246 }
40247
40248
40249 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40250 PyObject *resultobj;
40251 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40252 wxButton *result;
40253 PyObject * obj0 = 0 ;
40254 char *kwnames[] = {
40255 (char *) "self", NULL
40256 };
40257
40258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(1)) SWIG_fail;
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40264
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 {
40269 resultobj = wxPyMake_wxObject(result, 0);
40270 }
40271 return resultobj;
40272 fail:
40273 return NULL;
40274 }
40275
40276
40277 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40278 PyObject *obj;
40279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40280 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40281 Py_INCREF(obj);
40282 return Py_BuildValue((char *)"");
40283 }
40284 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40285 PyObject *resultobj;
40286 int arg1 = (int) 0 ;
40287 int arg2 = (int) 0 ;
40288 wxGBPosition *result;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char *kwnames[] = {
40292 (char *) "row",(char *) "col", NULL
40293 };
40294
40295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40296 if (obj0) {
40297 {
40298 arg1 = (int)(SWIG_As_int(obj0));
40299 if (SWIG_arg_fail(1)) SWIG_fail;
40300 }
40301 }
40302 if (obj1) {
40303 {
40304 arg2 = (int)(SWIG_As_int(obj1));
40305 if (SWIG_arg_fail(2)) SWIG_fail;
40306 }
40307 }
40308 {
40309 PyThreadState* __tstate = wxPyBeginAllowThreads();
40310 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40311
40312 wxPyEndAllowThreads(__tstate);
40313 if (PyErr_Occurred()) SWIG_fail;
40314 }
40315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40316 return resultobj;
40317 fail:
40318 return NULL;
40319 }
40320
40321
40322 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40323 PyObject *resultobj;
40324 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40325 int result;
40326 PyObject * obj0 = 0 ;
40327 char *kwnames[] = {
40328 (char *) "self", NULL
40329 };
40330
40331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40333 if (SWIG_arg_fail(1)) SWIG_fail;
40334 {
40335 PyThreadState* __tstate = wxPyBeginAllowThreads();
40336 result = (int)((wxGBPosition const *)arg1)->GetRow();
40337
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 {
40342 resultobj = SWIG_From_int((int)(result));
40343 }
40344 return resultobj;
40345 fail:
40346 return NULL;
40347 }
40348
40349
40350 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40351 PyObject *resultobj;
40352 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40353 int result;
40354 PyObject * obj0 = 0 ;
40355 char *kwnames[] = {
40356 (char *) "self", NULL
40357 };
40358
40359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40361 if (SWIG_arg_fail(1)) SWIG_fail;
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 result = (int)((wxGBPosition const *)arg1)->GetCol();
40365
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 {
40370 resultobj = SWIG_From_int((int)(result));
40371 }
40372 return resultobj;
40373 fail:
40374 return NULL;
40375 }
40376
40377
40378 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40379 PyObject *resultobj;
40380 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40381 int arg2 ;
40382 PyObject * obj0 = 0 ;
40383 PyObject * obj1 = 0 ;
40384 char *kwnames[] = {
40385 (char *) "self",(char *) "row", NULL
40386 };
40387
40388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40390 if (SWIG_arg_fail(1)) SWIG_fail;
40391 {
40392 arg2 = (int)(SWIG_As_int(obj1));
40393 if (SWIG_arg_fail(2)) SWIG_fail;
40394 }
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 (arg1)->SetRow(arg2);
40398
40399 wxPyEndAllowThreads(__tstate);
40400 if (PyErr_Occurred()) SWIG_fail;
40401 }
40402 Py_INCREF(Py_None); resultobj = Py_None;
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj;
40411 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40412 int arg2 ;
40413 PyObject * obj0 = 0 ;
40414 PyObject * obj1 = 0 ;
40415 char *kwnames[] = {
40416 (char *) "self",(char *) "col", NULL
40417 };
40418
40419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40421 if (SWIG_arg_fail(1)) SWIG_fail;
40422 {
40423 arg2 = (int)(SWIG_As_int(obj1));
40424 if (SWIG_arg_fail(2)) SWIG_fail;
40425 }
40426 {
40427 PyThreadState* __tstate = wxPyBeginAllowThreads();
40428 (arg1)->SetCol(arg2);
40429
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 Py_INCREF(Py_None); resultobj = Py_None;
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj;
40442 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40443 wxGBPosition *arg2 = 0 ;
40444 bool result;
40445 wxGBPosition temp2 ;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 char *kwnames[] = {
40449 (char *) "self",(char *) "other", NULL
40450 };
40451
40452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40454 if (SWIG_arg_fail(1)) SWIG_fail;
40455 {
40456 arg2 = &temp2;
40457 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40458 }
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40462
40463 wxPyEndAllowThreads(__tstate);
40464 if (PyErr_Occurred()) SWIG_fail;
40465 }
40466 {
40467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40468 }
40469 return resultobj;
40470 fail:
40471 return NULL;
40472 }
40473
40474
40475 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40476 PyObject *resultobj;
40477 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40478 wxGBPosition *arg2 = 0 ;
40479 bool result;
40480 wxGBPosition temp2 ;
40481 PyObject * obj0 = 0 ;
40482 PyObject * obj1 = 0 ;
40483 char *kwnames[] = {
40484 (char *) "self",(char *) "other", NULL
40485 };
40486
40487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40489 if (SWIG_arg_fail(1)) SWIG_fail;
40490 {
40491 arg2 = &temp2;
40492 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40493 }
40494 {
40495 PyThreadState* __tstate = wxPyBeginAllowThreads();
40496 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40497
40498 wxPyEndAllowThreads(__tstate);
40499 if (PyErr_Occurred()) SWIG_fail;
40500 }
40501 {
40502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40503 }
40504 return resultobj;
40505 fail:
40506 return NULL;
40507 }
40508
40509
40510 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40511 PyObject *resultobj;
40512 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40513 int arg2 = (int) 0 ;
40514 int arg3 = (int) 0 ;
40515 PyObject * obj0 = 0 ;
40516 PyObject * obj1 = 0 ;
40517 PyObject * obj2 = 0 ;
40518 char *kwnames[] = {
40519 (char *) "self",(char *) "row",(char *) "col", NULL
40520 };
40521
40522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40524 if (SWIG_arg_fail(1)) SWIG_fail;
40525 if (obj1) {
40526 {
40527 arg2 = (int)(SWIG_As_int(obj1));
40528 if (SWIG_arg_fail(2)) SWIG_fail;
40529 }
40530 }
40531 if (obj2) {
40532 {
40533 arg3 = (int)(SWIG_As_int(obj2));
40534 if (SWIG_arg_fail(3)) SWIG_fail;
40535 }
40536 }
40537 {
40538 PyThreadState* __tstate = wxPyBeginAllowThreads();
40539 wxGBPosition_Set(arg1,arg2,arg3);
40540
40541 wxPyEndAllowThreads(__tstate);
40542 if (PyErr_Occurred()) SWIG_fail;
40543 }
40544 Py_INCREF(Py_None); resultobj = Py_None;
40545 return resultobj;
40546 fail:
40547 return NULL;
40548 }
40549
40550
40551 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40552 PyObject *resultobj;
40553 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40554 PyObject *result;
40555 PyObject * obj0 = 0 ;
40556 char *kwnames[] = {
40557 (char *) "self", NULL
40558 };
40559
40560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40562 if (SWIG_arg_fail(1)) SWIG_fail;
40563 {
40564 PyThreadState* __tstate = wxPyBeginAllowThreads();
40565 result = (PyObject *)wxGBPosition_Get(arg1);
40566
40567 wxPyEndAllowThreads(__tstate);
40568 if (PyErr_Occurred()) SWIG_fail;
40569 }
40570 resultobj = result;
40571 return resultobj;
40572 fail:
40573 return NULL;
40574 }
40575
40576
40577 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40578 PyObject *obj;
40579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40580 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40581 Py_INCREF(obj);
40582 return Py_BuildValue((char *)"");
40583 }
40584 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj;
40586 int arg1 = (int) 1 ;
40587 int arg2 = (int) 1 ;
40588 wxGBSpan *result;
40589 PyObject * obj0 = 0 ;
40590 PyObject * obj1 = 0 ;
40591 char *kwnames[] = {
40592 (char *) "rowspan",(char *) "colspan", NULL
40593 };
40594
40595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40596 if (obj0) {
40597 {
40598 arg1 = (int)(SWIG_As_int(obj0));
40599 if (SWIG_arg_fail(1)) SWIG_fail;
40600 }
40601 }
40602 if (obj1) {
40603 {
40604 arg2 = (int)(SWIG_As_int(obj1));
40605 if (SWIG_arg_fail(2)) SWIG_fail;
40606 }
40607 }
40608 {
40609 PyThreadState* __tstate = wxPyBeginAllowThreads();
40610 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40611
40612 wxPyEndAllowThreads(__tstate);
40613 if (PyErr_Occurred()) SWIG_fail;
40614 }
40615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40616 return resultobj;
40617 fail:
40618 return NULL;
40619 }
40620
40621
40622 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40623 PyObject *resultobj;
40624 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40625 int result;
40626 PyObject * obj0 = 0 ;
40627 char *kwnames[] = {
40628 (char *) "self", NULL
40629 };
40630
40631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40633 if (SWIG_arg_fail(1)) SWIG_fail;
40634 {
40635 PyThreadState* __tstate = wxPyBeginAllowThreads();
40636 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40637
40638 wxPyEndAllowThreads(__tstate);
40639 if (PyErr_Occurred()) SWIG_fail;
40640 }
40641 {
40642 resultobj = SWIG_From_int((int)(result));
40643 }
40644 return resultobj;
40645 fail:
40646 return NULL;
40647 }
40648
40649
40650 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40651 PyObject *resultobj;
40652 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40653 int result;
40654 PyObject * obj0 = 0 ;
40655 char *kwnames[] = {
40656 (char *) "self", NULL
40657 };
40658
40659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40661 if (SWIG_arg_fail(1)) SWIG_fail;
40662 {
40663 PyThreadState* __tstate = wxPyBeginAllowThreads();
40664 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40665
40666 wxPyEndAllowThreads(__tstate);
40667 if (PyErr_Occurred()) SWIG_fail;
40668 }
40669 {
40670 resultobj = SWIG_From_int((int)(result));
40671 }
40672 return resultobj;
40673 fail:
40674 return NULL;
40675 }
40676
40677
40678 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40679 PyObject *resultobj;
40680 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40681 int arg2 ;
40682 PyObject * obj0 = 0 ;
40683 PyObject * obj1 = 0 ;
40684 char *kwnames[] = {
40685 (char *) "self",(char *) "rowspan", NULL
40686 };
40687
40688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40690 if (SWIG_arg_fail(1)) SWIG_fail;
40691 {
40692 arg2 = (int)(SWIG_As_int(obj1));
40693 if (SWIG_arg_fail(2)) SWIG_fail;
40694 }
40695 {
40696 PyThreadState* __tstate = wxPyBeginAllowThreads();
40697 (arg1)->SetRowspan(arg2);
40698
40699 wxPyEndAllowThreads(__tstate);
40700 if (PyErr_Occurred()) SWIG_fail;
40701 }
40702 Py_INCREF(Py_None); resultobj = Py_None;
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj;
40711 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40712 int arg2 ;
40713 PyObject * obj0 = 0 ;
40714 PyObject * obj1 = 0 ;
40715 char *kwnames[] = {
40716 (char *) "self",(char *) "colspan", NULL
40717 };
40718
40719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40721 if (SWIG_arg_fail(1)) SWIG_fail;
40722 {
40723 arg2 = (int)(SWIG_As_int(obj1));
40724 if (SWIG_arg_fail(2)) SWIG_fail;
40725 }
40726 {
40727 PyThreadState* __tstate = wxPyBeginAllowThreads();
40728 (arg1)->SetColspan(arg2);
40729
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 Py_INCREF(Py_None); resultobj = Py_None;
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj;
40742 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40743 wxGBSpan *arg2 = 0 ;
40744 bool result;
40745 wxGBSpan temp2 ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 char *kwnames[] = {
40749 (char *) "self",(char *) "other", NULL
40750 };
40751
40752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40754 if (SWIG_arg_fail(1)) SWIG_fail;
40755 {
40756 arg2 = &temp2;
40757 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40758 }
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40762
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 {
40767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40768 }
40769 return resultobj;
40770 fail:
40771 return NULL;
40772 }
40773
40774
40775 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj;
40777 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40778 wxGBSpan *arg2 = 0 ;
40779 bool result;
40780 wxGBSpan temp2 ;
40781 PyObject * obj0 = 0 ;
40782 PyObject * obj1 = 0 ;
40783 char *kwnames[] = {
40784 (char *) "self",(char *) "other", NULL
40785 };
40786
40787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40789 if (SWIG_arg_fail(1)) SWIG_fail;
40790 {
40791 arg2 = &temp2;
40792 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40793 }
40794 {
40795 PyThreadState* __tstate = wxPyBeginAllowThreads();
40796 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40797
40798 wxPyEndAllowThreads(__tstate);
40799 if (PyErr_Occurred()) SWIG_fail;
40800 }
40801 {
40802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40803 }
40804 return resultobj;
40805 fail:
40806 return NULL;
40807 }
40808
40809
40810 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40811 PyObject *resultobj;
40812 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40813 int arg2 = (int) 1 ;
40814 int arg3 = (int) 1 ;
40815 PyObject * obj0 = 0 ;
40816 PyObject * obj1 = 0 ;
40817 PyObject * obj2 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(1)) SWIG_fail;
40825 if (obj1) {
40826 {
40827 arg2 = (int)(SWIG_As_int(obj1));
40828 if (SWIG_arg_fail(2)) SWIG_fail;
40829 }
40830 }
40831 if (obj2) {
40832 {
40833 arg3 = (int)(SWIG_As_int(obj2));
40834 if (SWIG_arg_fail(3)) SWIG_fail;
40835 }
40836 }
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 wxGBSpan_Set(arg1,arg2,arg3);
40840
40841 wxPyEndAllowThreads(__tstate);
40842 if (PyErr_Occurred()) SWIG_fail;
40843 }
40844 Py_INCREF(Py_None); resultobj = Py_None;
40845 return resultobj;
40846 fail:
40847 return NULL;
40848 }
40849
40850
40851 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40852 PyObject *resultobj;
40853 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40854 PyObject *result;
40855 PyObject * obj0 = 0 ;
40856 char *kwnames[] = {
40857 (char *) "self", NULL
40858 };
40859
40860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
40861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40862 if (SWIG_arg_fail(1)) SWIG_fail;
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 result = (PyObject *)wxGBSpan_Get(arg1);
40866
40867 wxPyEndAllowThreads(__tstate);
40868 if (PyErr_Occurred()) SWIG_fail;
40869 }
40870 resultobj = result;
40871 return resultobj;
40872 fail:
40873 return NULL;
40874 }
40875
40876
40877 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
40878 PyObject *obj;
40879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40880 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
40881 Py_INCREF(obj);
40882 return Py_BuildValue((char *)"");
40883 }
40884 static int _wrap_DefaultSpan_set(PyObject *) {
40885 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
40886 return 1;
40887 }
40888
40889
40890 static PyObject *_wrap_DefaultSpan_get(void) {
40891 PyObject *pyobj;
40892
40893 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
40894 return pyobj;
40895 }
40896
40897
40898 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
40899 PyObject *resultobj;
40900 wxGBSizerItem *result;
40901 char *kwnames[] = {
40902 NULL
40903 };
40904
40905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 result = (wxGBSizerItem *)new wxGBSizerItem();
40909
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj;
40922 wxWindow *arg1 = (wxWindow *) 0 ;
40923 wxGBPosition *arg2 = 0 ;
40924 wxGBSpan *arg3 = 0 ;
40925 int arg4 ;
40926 int arg5 ;
40927 PyObject *arg6 = (PyObject *) NULL ;
40928 wxGBSizerItem *result;
40929 wxGBPosition temp2 ;
40930 wxGBSpan temp3 ;
40931 PyObject * obj0 = 0 ;
40932 PyObject * obj1 = 0 ;
40933 PyObject * obj2 = 0 ;
40934 PyObject * obj3 = 0 ;
40935 PyObject * obj4 = 0 ;
40936 PyObject * obj5 = 0 ;
40937 char *kwnames[] = {
40938 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40939 };
40940
40941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40943 if (SWIG_arg_fail(1)) SWIG_fail;
40944 {
40945 arg2 = &temp2;
40946 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40947 }
40948 {
40949 arg3 = &temp3;
40950 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40951 }
40952 {
40953 arg4 = (int)(SWIG_As_int(obj3));
40954 if (SWIG_arg_fail(4)) SWIG_fail;
40955 }
40956 {
40957 arg5 = (int)(SWIG_As_int(obj4));
40958 if (SWIG_arg_fail(5)) SWIG_fail;
40959 }
40960 if (obj5) {
40961 arg6 = obj5;
40962 }
40963 {
40964 PyThreadState* __tstate = wxPyBeginAllowThreads();
40965 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40966
40967 wxPyEndAllowThreads(__tstate);
40968 if (PyErr_Occurred()) SWIG_fail;
40969 }
40970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj;
40979 wxSizer *arg1 = (wxSizer *) 0 ;
40980 wxGBPosition *arg2 = 0 ;
40981 wxGBSpan *arg3 = 0 ;
40982 int arg4 ;
40983 int arg5 ;
40984 PyObject *arg6 = (PyObject *) NULL ;
40985 wxGBSizerItem *result;
40986 wxGBPosition temp2 ;
40987 wxGBSpan temp3 ;
40988 PyObject * obj0 = 0 ;
40989 PyObject * obj1 = 0 ;
40990 PyObject * obj2 = 0 ;
40991 PyObject * obj3 = 0 ;
40992 PyObject * obj4 = 0 ;
40993 PyObject * obj5 = 0 ;
40994 char *kwnames[] = {
40995 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40996 };
40997
40998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41000 if (SWIG_arg_fail(1)) SWIG_fail;
41001 {
41002 arg2 = &temp2;
41003 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41004 }
41005 {
41006 arg3 = &temp3;
41007 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41008 }
41009 {
41010 arg4 = (int)(SWIG_As_int(obj3));
41011 if (SWIG_arg_fail(4)) SWIG_fail;
41012 }
41013 {
41014 arg5 = (int)(SWIG_As_int(obj4));
41015 if (SWIG_arg_fail(5)) SWIG_fail;
41016 }
41017 if (obj5) {
41018 arg6 = obj5;
41019 }
41020 {
41021 PyThreadState* __tstate = wxPyBeginAllowThreads();
41022 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41023
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj;
41036 int arg1 ;
41037 int arg2 ;
41038 wxGBPosition *arg3 = 0 ;
41039 wxGBSpan *arg4 = 0 ;
41040 int arg5 ;
41041 int arg6 ;
41042 PyObject *arg7 = (PyObject *) NULL ;
41043 wxGBSizerItem *result;
41044 wxGBPosition temp3 ;
41045 wxGBSpan temp4 ;
41046 PyObject * obj0 = 0 ;
41047 PyObject * obj1 = 0 ;
41048 PyObject * obj2 = 0 ;
41049 PyObject * obj3 = 0 ;
41050 PyObject * obj4 = 0 ;
41051 PyObject * obj5 = 0 ;
41052 PyObject * obj6 = 0 ;
41053 char *kwnames[] = {
41054 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41055 };
41056
41057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41058 {
41059 arg1 = (int)(SWIG_As_int(obj0));
41060 if (SWIG_arg_fail(1)) SWIG_fail;
41061 }
41062 {
41063 arg2 = (int)(SWIG_As_int(obj1));
41064 if (SWIG_arg_fail(2)) SWIG_fail;
41065 }
41066 {
41067 arg3 = &temp3;
41068 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41069 }
41070 {
41071 arg4 = &temp4;
41072 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41073 }
41074 {
41075 arg5 = (int)(SWIG_As_int(obj4));
41076 if (SWIG_arg_fail(5)) SWIG_fail;
41077 }
41078 {
41079 arg6 = (int)(SWIG_As_int(obj5));
41080 if (SWIG_arg_fail(6)) SWIG_fail;
41081 }
41082 if (obj6) {
41083 arg7 = obj6;
41084 }
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41088
41089 wxPyEndAllowThreads(__tstate);
41090 if (PyErr_Occurred()) SWIG_fail;
41091 }
41092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41093 return resultobj;
41094 fail:
41095 return NULL;
41096 }
41097
41098
41099 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41100 PyObject *resultobj;
41101 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41102 wxGBPosition result;
41103 PyObject * obj0 = 0 ;
41104 char *kwnames[] = {
41105 (char *) "self", NULL
41106 };
41107
41108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41110 if (SWIG_arg_fail(1)) SWIG_fail;
41111 {
41112 PyThreadState* __tstate = wxPyBeginAllowThreads();
41113 result = ((wxGBSizerItem const *)arg1)->GetPos();
41114
41115 wxPyEndAllowThreads(__tstate);
41116 if (PyErr_Occurred()) SWIG_fail;
41117 }
41118 {
41119 wxGBPosition * resultptr;
41120 resultptr = new wxGBPosition((wxGBPosition &)(result));
41121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41122 }
41123 return resultobj;
41124 fail:
41125 return NULL;
41126 }
41127
41128
41129 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41130 PyObject *resultobj;
41131 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41132 wxGBSpan result;
41133 PyObject * obj0 = 0 ;
41134 char *kwnames[] = {
41135 (char *) "self", NULL
41136 };
41137
41138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41140 if (SWIG_arg_fail(1)) SWIG_fail;
41141 {
41142 PyThreadState* __tstate = wxPyBeginAllowThreads();
41143 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41144
41145 wxPyEndAllowThreads(__tstate);
41146 if (PyErr_Occurred()) SWIG_fail;
41147 }
41148 {
41149 wxGBSpan * resultptr;
41150 resultptr = new wxGBSpan((wxGBSpan &)(result));
41151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41152 }
41153 return resultobj;
41154 fail:
41155 return NULL;
41156 }
41157
41158
41159 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41160 PyObject *resultobj;
41161 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41162 wxGBPosition *arg2 = 0 ;
41163 bool result;
41164 wxGBPosition temp2 ;
41165 PyObject * obj0 = 0 ;
41166 PyObject * obj1 = 0 ;
41167 char *kwnames[] = {
41168 (char *) "self",(char *) "pos", NULL
41169 };
41170
41171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41173 if (SWIG_arg_fail(1)) SWIG_fail;
41174 {
41175 arg2 = &temp2;
41176 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41177 }
41178 {
41179 PyThreadState* __tstate = wxPyBeginAllowThreads();
41180 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41181
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41187 }
41188 return resultobj;
41189 fail:
41190 return NULL;
41191 }
41192
41193
41194 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41195 PyObject *resultobj;
41196 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41197 wxGBSpan *arg2 = 0 ;
41198 bool result;
41199 wxGBSpan temp2 ;
41200 PyObject * obj0 = 0 ;
41201 PyObject * obj1 = 0 ;
41202 char *kwnames[] = {
41203 (char *) "self",(char *) "span", NULL
41204 };
41205
41206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41208 if (SWIG_arg_fail(1)) SWIG_fail;
41209 {
41210 arg2 = &temp2;
41211 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41212 }
41213 {
41214 PyThreadState* __tstate = wxPyBeginAllowThreads();
41215 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41216
41217 wxPyEndAllowThreads(__tstate);
41218 if (PyErr_Occurred()) SWIG_fail;
41219 }
41220 {
41221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41222 }
41223 return resultobj;
41224 fail:
41225 return NULL;
41226 }
41227
41228
41229 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41230 PyObject *resultobj;
41231 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41232 wxGBSizerItem *arg2 = 0 ;
41233 bool result;
41234 PyObject * obj0 = 0 ;
41235 PyObject * obj1 = 0 ;
41236 char *kwnames[] = {
41237 (char *) "self",(char *) "other", NULL
41238 };
41239
41240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41242 if (SWIG_arg_fail(1)) SWIG_fail;
41243 {
41244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41245 if (SWIG_arg_fail(2)) SWIG_fail;
41246 if (arg2 == NULL) {
41247 SWIG_null_ref("wxGBSizerItem");
41248 }
41249 if (SWIG_arg_fail(2)) SWIG_fail;
41250 }
41251 {
41252 PyThreadState* __tstate = wxPyBeginAllowThreads();
41253 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41254
41255 wxPyEndAllowThreads(__tstate);
41256 if (PyErr_Occurred()) SWIG_fail;
41257 }
41258 {
41259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41260 }
41261 return resultobj;
41262 fail:
41263 return NULL;
41264 }
41265
41266
41267 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41268 PyObject *resultobj;
41269 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41270 wxGBPosition *arg2 = 0 ;
41271 wxGBSpan *arg3 = 0 ;
41272 bool result;
41273 wxGBPosition temp2 ;
41274 wxGBSpan temp3 ;
41275 PyObject * obj0 = 0 ;
41276 PyObject * obj1 = 0 ;
41277 PyObject * obj2 = 0 ;
41278 char *kwnames[] = {
41279 (char *) "self",(char *) "pos",(char *) "span", NULL
41280 };
41281
41282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41284 if (SWIG_arg_fail(1)) SWIG_fail;
41285 {
41286 arg2 = &temp2;
41287 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41288 }
41289 {
41290 arg3 = &temp3;
41291 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41292 }
41293 {
41294 PyThreadState* __tstate = wxPyBeginAllowThreads();
41295 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41296
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 {
41301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41302 }
41303 return resultobj;
41304 fail:
41305 return NULL;
41306 }
41307
41308
41309 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41310 PyObject *resultobj;
41311 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41312 wxGBPosition result;
41313 PyObject * obj0 = 0 ;
41314 char *kwnames[] = {
41315 (char *) "self", NULL
41316 };
41317
41318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41320 if (SWIG_arg_fail(1)) SWIG_fail;
41321 {
41322 PyThreadState* __tstate = wxPyBeginAllowThreads();
41323 result = wxGBSizerItem_GetEndPos(arg1);
41324
41325 wxPyEndAllowThreads(__tstate);
41326 if (PyErr_Occurred()) SWIG_fail;
41327 }
41328 {
41329 wxGBPosition * resultptr;
41330 resultptr = new wxGBPosition((wxGBPosition &)(result));
41331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41332 }
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41340 PyObject *resultobj;
41341 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41342 wxGridBagSizer *result;
41343 PyObject * obj0 = 0 ;
41344 char *kwnames[] = {
41345 (char *) "self", NULL
41346 };
41347
41348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41350 if (SWIG_arg_fail(1)) SWIG_fail;
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41354
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj;
41367 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41368 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41369 PyObject * obj0 = 0 ;
41370 PyObject * obj1 = 0 ;
41371 char *kwnames[] = {
41372 (char *) "self",(char *) "sizer", NULL
41373 };
41374
41375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41377 if (SWIG_arg_fail(1)) SWIG_fail;
41378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41379 if (SWIG_arg_fail(2)) SWIG_fail;
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 (arg1)->SetGBSizer(arg2);
41383
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 Py_INCREF(Py_None); resultobj = Py_None;
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41395 PyObject *obj;
41396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41397 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41398 Py_INCREF(obj);
41399 return Py_BuildValue((char *)"");
41400 }
41401 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41402 PyObject *resultobj;
41403 int arg1 = (int) 0 ;
41404 int arg2 = (int) 0 ;
41405 wxGridBagSizer *result;
41406 PyObject * obj0 = 0 ;
41407 PyObject * obj1 = 0 ;
41408 char *kwnames[] = {
41409 (char *) "vgap",(char *) "hgap", NULL
41410 };
41411
41412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41413 if (obj0) {
41414 {
41415 arg1 = (int)(SWIG_As_int(obj0));
41416 if (SWIG_arg_fail(1)) SWIG_fail;
41417 }
41418 }
41419 if (obj1) {
41420 {
41421 arg2 = (int)(SWIG_As_int(obj1));
41422 if (SWIG_arg_fail(2)) SWIG_fail;
41423 }
41424 }
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41428
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41440 PyObject *resultobj;
41441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41442 PyObject *arg2 = (PyObject *) 0 ;
41443 wxGBPosition *arg3 = 0 ;
41444 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41445 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41446 int arg5 = (int) 0 ;
41447 int arg6 = (int) 0 ;
41448 PyObject *arg7 = (PyObject *) NULL ;
41449 wxGBSizerItem *result;
41450 wxGBPosition temp3 ;
41451 wxGBSpan temp4 ;
41452 PyObject * obj0 = 0 ;
41453 PyObject * obj1 = 0 ;
41454 PyObject * obj2 = 0 ;
41455 PyObject * obj3 = 0 ;
41456 PyObject * obj4 = 0 ;
41457 PyObject * obj5 = 0 ;
41458 PyObject * obj6 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 arg2 = obj1;
41467 {
41468 arg3 = &temp3;
41469 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41470 }
41471 if (obj3) {
41472 {
41473 arg4 = &temp4;
41474 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41475 }
41476 }
41477 if (obj4) {
41478 {
41479 arg5 = (int)(SWIG_As_int(obj4));
41480 if (SWIG_arg_fail(5)) SWIG_fail;
41481 }
41482 }
41483 if (obj5) {
41484 {
41485 arg6 = (int)(SWIG_As_int(obj5));
41486 if (SWIG_arg_fail(6)) SWIG_fail;
41487 }
41488 }
41489 if (obj6) {
41490 arg7 = obj6;
41491 }
41492 {
41493 PyThreadState* __tstate = wxPyBeginAllowThreads();
41494 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41495
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41500 return resultobj;
41501 fail:
41502 return NULL;
41503 }
41504
41505
41506 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41507 PyObject *resultobj;
41508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41509 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41510 wxGBSizerItem *result;
41511 PyObject * obj0 = 0 ;
41512 PyObject * obj1 = 0 ;
41513 char *kwnames[] = {
41514 (char *) "self",(char *) "item", NULL
41515 };
41516
41517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41519 if (SWIG_arg_fail(1)) SWIG_fail;
41520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41521 if (SWIG_arg_fail(2)) SWIG_fail;
41522 {
41523 PyThreadState* __tstate = wxPyBeginAllowThreads();
41524 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41525
41526 wxPyEndAllowThreads(__tstate);
41527 if (PyErr_Occurred()) SWIG_fail;
41528 }
41529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41530 return resultobj;
41531 fail:
41532 return NULL;
41533 }
41534
41535
41536 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41537 PyObject *resultobj;
41538 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41539 int arg2 ;
41540 int arg3 ;
41541 wxSize result;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 PyObject * obj2 = 0 ;
41545 char *kwnames[] = {
41546 (char *) "self",(char *) "row",(char *) "col", NULL
41547 };
41548
41549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41551 if (SWIG_arg_fail(1)) SWIG_fail;
41552 {
41553 arg2 = (int)(SWIG_As_int(obj1));
41554 if (SWIG_arg_fail(2)) SWIG_fail;
41555 }
41556 {
41557 arg3 = (int)(SWIG_As_int(obj2));
41558 if (SWIG_arg_fail(3)) SWIG_fail;
41559 }
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41563
41564 wxPyEndAllowThreads(__tstate);
41565 if (PyErr_Occurred()) SWIG_fail;
41566 }
41567 {
41568 wxSize * resultptr;
41569 resultptr = new wxSize((wxSize &)(result));
41570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41571 }
41572 return resultobj;
41573 fail:
41574 return NULL;
41575 }
41576
41577
41578 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41579 PyObject *resultobj;
41580 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41581 wxSize result;
41582 PyObject * obj0 = 0 ;
41583 char *kwnames[] = {
41584 (char *) "self", NULL
41585 };
41586
41587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41589 if (SWIG_arg_fail(1)) SWIG_fail;
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41593
41594 wxPyEndAllowThreads(__tstate);
41595 if (PyErr_Occurred()) SWIG_fail;
41596 }
41597 {
41598 wxSize * resultptr;
41599 resultptr = new wxSize((wxSize &)(result));
41600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41601 }
41602 return resultobj;
41603 fail:
41604 return NULL;
41605 }
41606
41607
41608 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41609 PyObject *resultobj;
41610 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41611 wxSize *arg2 = 0 ;
41612 wxSize temp2 ;
41613 PyObject * obj0 = 0 ;
41614 PyObject * obj1 = 0 ;
41615 char *kwnames[] = {
41616 (char *) "self",(char *) "sz", NULL
41617 };
41618
41619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41621 if (SWIG_arg_fail(1)) SWIG_fail;
41622 {
41623 arg2 = &temp2;
41624 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41625 }
41626 {
41627 PyThreadState* __tstate = wxPyBeginAllowThreads();
41628 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41629
41630 wxPyEndAllowThreads(__tstate);
41631 if (PyErr_Occurred()) SWIG_fail;
41632 }
41633 Py_INCREF(Py_None); resultobj = Py_None;
41634 return resultobj;
41635 fail:
41636 return NULL;
41637 }
41638
41639
41640 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41641 PyObject *resultobj;
41642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41643 wxWindow *arg2 = (wxWindow *) 0 ;
41644 wxGBPosition result;
41645 PyObject * obj0 = 0 ;
41646 PyObject * obj1 = 0 ;
41647
41648 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41650 if (SWIG_arg_fail(1)) SWIG_fail;
41651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41652 if (SWIG_arg_fail(2)) SWIG_fail;
41653 {
41654 PyThreadState* __tstate = wxPyBeginAllowThreads();
41655 result = (arg1)->GetItemPosition(arg2);
41656
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 {
41661 wxGBPosition * resultptr;
41662 resultptr = new wxGBPosition((wxGBPosition &)(result));
41663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41664 }
41665 return resultobj;
41666 fail:
41667 return NULL;
41668 }
41669
41670
41671 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41672 PyObject *resultobj;
41673 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41674 wxSizer *arg2 = (wxSizer *) 0 ;
41675 wxGBPosition result;
41676 PyObject * obj0 = 0 ;
41677 PyObject * obj1 = 0 ;
41678
41679 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41681 if (SWIG_arg_fail(1)) SWIG_fail;
41682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41683 if (SWIG_arg_fail(2)) SWIG_fail;
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (arg1)->GetItemPosition(arg2);
41687
41688 wxPyEndAllowThreads(__tstate);
41689 if (PyErr_Occurred()) SWIG_fail;
41690 }
41691 {
41692 wxGBPosition * resultptr;
41693 resultptr = new wxGBPosition((wxGBPosition &)(result));
41694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41695 }
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41703 PyObject *resultobj;
41704 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41705 size_t arg2 ;
41706 wxGBPosition result;
41707 PyObject * obj0 = 0 ;
41708 PyObject * obj1 = 0 ;
41709
41710 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41712 if (SWIG_arg_fail(1)) SWIG_fail;
41713 {
41714 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41715 if (SWIG_arg_fail(2)) SWIG_fail;
41716 }
41717 {
41718 PyThreadState* __tstate = wxPyBeginAllowThreads();
41719 result = (arg1)->GetItemPosition(arg2);
41720
41721 wxPyEndAllowThreads(__tstate);
41722 if (PyErr_Occurred()) SWIG_fail;
41723 }
41724 {
41725 wxGBPosition * resultptr;
41726 resultptr = new wxGBPosition((wxGBPosition &)(result));
41727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41728 }
41729 return resultobj;
41730 fail:
41731 return NULL;
41732 }
41733
41734
41735 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41736 int argc;
41737 PyObject *argv[3];
41738 int ii;
41739
41740 argc = PyObject_Length(args);
41741 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41742 argv[ii] = PyTuple_GetItem(args,ii);
41743 }
41744 if (argc == 2) {
41745 int _v;
41746 {
41747 void *ptr;
41748 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41749 _v = 0;
41750 PyErr_Clear();
41751 } else {
41752 _v = 1;
41753 }
41754 }
41755 if (_v) {
41756 {
41757 void *ptr;
41758 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41759 _v = 0;
41760 PyErr_Clear();
41761 } else {
41762 _v = 1;
41763 }
41764 }
41765 if (_v) {
41766 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41767 }
41768 }
41769 }
41770 if (argc == 2) {
41771 int _v;
41772 {
41773 void *ptr;
41774 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41775 _v = 0;
41776 PyErr_Clear();
41777 } else {
41778 _v = 1;
41779 }
41780 }
41781 if (_v) {
41782 {
41783 void *ptr;
41784 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41785 _v = 0;
41786 PyErr_Clear();
41787 } else {
41788 _v = 1;
41789 }
41790 }
41791 if (_v) {
41792 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41793 }
41794 }
41795 }
41796 if (argc == 2) {
41797 int _v;
41798 {
41799 void *ptr;
41800 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41801 _v = 0;
41802 PyErr_Clear();
41803 } else {
41804 _v = 1;
41805 }
41806 }
41807 if (_v) {
41808 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41809 if (_v) {
41810 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
41811 }
41812 }
41813 }
41814
41815 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
41816 return NULL;
41817 }
41818
41819
41820 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41821 PyObject *resultobj;
41822 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41823 wxWindow *arg2 = (wxWindow *) 0 ;
41824 wxGBPosition *arg3 = 0 ;
41825 bool result;
41826 wxGBPosition temp3 ;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 PyObject * obj2 = 0 ;
41830
41831 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41833 if (SWIG_arg_fail(1)) SWIG_fail;
41834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41835 if (SWIG_arg_fail(2)) SWIG_fail;
41836 {
41837 arg3 = &temp3;
41838 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41839 }
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41843
41844 wxPyEndAllowThreads(__tstate);
41845 if (PyErr_Occurred()) SWIG_fail;
41846 }
41847 {
41848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41849 }
41850 return resultobj;
41851 fail:
41852 return NULL;
41853 }
41854
41855
41856 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41857 PyObject *resultobj;
41858 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41859 wxSizer *arg2 = (wxSizer *) 0 ;
41860 wxGBPosition *arg3 = 0 ;
41861 bool result;
41862 wxGBPosition temp3 ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 PyObject * obj2 = 0 ;
41866
41867 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41869 if (SWIG_arg_fail(1)) SWIG_fail;
41870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41871 if (SWIG_arg_fail(2)) SWIG_fail;
41872 {
41873 arg3 = &temp3;
41874 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41875 }
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41879
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41885 }
41886 return resultobj;
41887 fail:
41888 return NULL;
41889 }
41890
41891
41892 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41893 PyObject *resultobj;
41894 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41895 size_t arg2 ;
41896 wxGBPosition *arg3 = 0 ;
41897 bool result;
41898 wxGBPosition temp3 ;
41899 PyObject * obj0 = 0 ;
41900 PyObject * obj1 = 0 ;
41901 PyObject * obj2 = 0 ;
41902
41903 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41905 if (SWIG_arg_fail(1)) SWIG_fail;
41906 {
41907 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41908 if (SWIG_arg_fail(2)) SWIG_fail;
41909 }
41910 {
41911 arg3 = &temp3;
41912 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41913 }
41914 {
41915 PyThreadState* __tstate = wxPyBeginAllowThreads();
41916 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41917
41918 wxPyEndAllowThreads(__tstate);
41919 if (PyErr_Occurred()) SWIG_fail;
41920 }
41921 {
41922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41923 }
41924 return resultobj;
41925 fail:
41926 return NULL;
41927 }
41928
41929
41930 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
41931 int argc;
41932 PyObject *argv[4];
41933 int ii;
41934
41935 argc = PyObject_Length(args);
41936 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
41937 argv[ii] = PyTuple_GetItem(args,ii);
41938 }
41939 if (argc == 3) {
41940 int _v;
41941 {
41942 void *ptr;
41943 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41944 _v = 0;
41945 PyErr_Clear();
41946 } else {
41947 _v = 1;
41948 }
41949 }
41950 if (_v) {
41951 {
41952 void *ptr;
41953 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41954 _v = 0;
41955 PyErr_Clear();
41956 } else {
41957 _v = 1;
41958 }
41959 }
41960 if (_v) {
41961 {
41962 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41963 }
41964 if (_v) {
41965 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
41966 }
41967 }
41968 }
41969 }
41970 if (argc == 3) {
41971 int _v;
41972 {
41973 void *ptr;
41974 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41975 _v = 0;
41976 PyErr_Clear();
41977 } else {
41978 _v = 1;
41979 }
41980 }
41981 if (_v) {
41982 {
41983 void *ptr;
41984 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41985 _v = 0;
41986 PyErr_Clear();
41987 } else {
41988 _v = 1;
41989 }
41990 }
41991 if (_v) {
41992 {
41993 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41994 }
41995 if (_v) {
41996 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
41997 }
41998 }
41999 }
42000 }
42001 if (argc == 3) {
42002 int _v;
42003 {
42004 void *ptr;
42005 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42006 _v = 0;
42007 PyErr_Clear();
42008 } else {
42009 _v = 1;
42010 }
42011 }
42012 if (_v) {
42013 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42014 if (_v) {
42015 {
42016 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42017 }
42018 if (_v) {
42019 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42020 }
42021 }
42022 }
42023 }
42024
42025 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42026 return NULL;
42027 }
42028
42029
42030 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42031 PyObject *resultobj;
42032 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42033 wxWindow *arg2 = (wxWindow *) 0 ;
42034 wxGBSpan result;
42035 PyObject * obj0 = 0 ;
42036 PyObject * obj1 = 0 ;
42037
42038 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42040 if (SWIG_arg_fail(1)) SWIG_fail;
42041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42042 if (SWIG_arg_fail(2)) SWIG_fail;
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 result = (arg1)->GetItemSpan(arg2);
42046
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 {
42051 wxGBSpan * resultptr;
42052 resultptr = new wxGBSpan((wxGBSpan &)(result));
42053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42054 }
42055 return resultobj;
42056 fail:
42057 return NULL;
42058 }
42059
42060
42061 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42062 PyObject *resultobj;
42063 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42064 wxSizer *arg2 = (wxSizer *) 0 ;
42065 wxGBSpan result;
42066 PyObject * obj0 = 0 ;
42067 PyObject * obj1 = 0 ;
42068
42069 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42071 if (SWIG_arg_fail(1)) SWIG_fail;
42072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42073 if (SWIG_arg_fail(2)) SWIG_fail;
42074 {
42075 PyThreadState* __tstate = wxPyBeginAllowThreads();
42076 result = (arg1)->GetItemSpan(arg2);
42077
42078 wxPyEndAllowThreads(__tstate);
42079 if (PyErr_Occurred()) SWIG_fail;
42080 }
42081 {
42082 wxGBSpan * resultptr;
42083 resultptr = new wxGBSpan((wxGBSpan &)(result));
42084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42085 }
42086 return resultobj;
42087 fail:
42088 return NULL;
42089 }
42090
42091
42092 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42093 PyObject *resultobj;
42094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42095 size_t arg2 ;
42096 wxGBSpan result;
42097 PyObject * obj0 = 0 ;
42098 PyObject * obj1 = 0 ;
42099
42100 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42102 if (SWIG_arg_fail(1)) SWIG_fail;
42103 {
42104 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42105 if (SWIG_arg_fail(2)) SWIG_fail;
42106 }
42107 {
42108 PyThreadState* __tstate = wxPyBeginAllowThreads();
42109 result = (arg1)->GetItemSpan(arg2);
42110
42111 wxPyEndAllowThreads(__tstate);
42112 if (PyErr_Occurred()) SWIG_fail;
42113 }
42114 {
42115 wxGBSpan * resultptr;
42116 resultptr = new wxGBSpan((wxGBSpan &)(result));
42117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42118 }
42119 return resultobj;
42120 fail:
42121 return NULL;
42122 }
42123
42124
42125 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42126 int argc;
42127 PyObject *argv[3];
42128 int ii;
42129
42130 argc = PyObject_Length(args);
42131 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42132 argv[ii] = PyTuple_GetItem(args,ii);
42133 }
42134 if (argc == 2) {
42135 int _v;
42136 {
42137 void *ptr;
42138 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42139 _v = 0;
42140 PyErr_Clear();
42141 } else {
42142 _v = 1;
42143 }
42144 }
42145 if (_v) {
42146 {
42147 void *ptr;
42148 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42149 _v = 0;
42150 PyErr_Clear();
42151 } else {
42152 _v = 1;
42153 }
42154 }
42155 if (_v) {
42156 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42157 }
42158 }
42159 }
42160 if (argc == 2) {
42161 int _v;
42162 {
42163 void *ptr;
42164 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42165 _v = 0;
42166 PyErr_Clear();
42167 } else {
42168 _v = 1;
42169 }
42170 }
42171 if (_v) {
42172 {
42173 void *ptr;
42174 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42175 _v = 0;
42176 PyErr_Clear();
42177 } else {
42178 _v = 1;
42179 }
42180 }
42181 if (_v) {
42182 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42183 }
42184 }
42185 }
42186 if (argc == 2) {
42187 int _v;
42188 {
42189 void *ptr;
42190 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42191 _v = 0;
42192 PyErr_Clear();
42193 } else {
42194 _v = 1;
42195 }
42196 }
42197 if (_v) {
42198 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42199 if (_v) {
42200 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42201 }
42202 }
42203 }
42204
42205 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42206 return NULL;
42207 }
42208
42209
42210 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42211 PyObject *resultobj;
42212 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42213 wxWindow *arg2 = (wxWindow *) 0 ;
42214 wxGBSpan *arg3 = 0 ;
42215 bool result;
42216 wxGBSpan temp3 ;
42217 PyObject * obj0 = 0 ;
42218 PyObject * obj1 = 0 ;
42219 PyObject * obj2 = 0 ;
42220
42221 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42223 if (SWIG_arg_fail(1)) SWIG_fail;
42224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42225 if (SWIG_arg_fail(2)) SWIG_fail;
42226 {
42227 arg3 = &temp3;
42228 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42229 }
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42233
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 {
42238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42239 }
42240 return resultobj;
42241 fail:
42242 return NULL;
42243 }
42244
42245
42246 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42247 PyObject *resultobj;
42248 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42249 wxSizer *arg2 = (wxSizer *) 0 ;
42250 wxGBSpan *arg3 = 0 ;
42251 bool result;
42252 wxGBSpan temp3 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 PyObject * obj2 = 0 ;
42256
42257 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42259 if (SWIG_arg_fail(1)) SWIG_fail;
42260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42261 if (SWIG_arg_fail(2)) SWIG_fail;
42262 {
42263 arg3 = &temp3;
42264 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42265 }
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42269
42270 wxPyEndAllowThreads(__tstate);
42271 if (PyErr_Occurred()) SWIG_fail;
42272 }
42273 {
42274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42283 PyObject *resultobj;
42284 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42285 size_t arg2 ;
42286 wxGBSpan *arg3 = 0 ;
42287 bool result;
42288 wxGBSpan temp3 ;
42289 PyObject * obj0 = 0 ;
42290 PyObject * obj1 = 0 ;
42291 PyObject * obj2 = 0 ;
42292
42293 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42295 if (SWIG_arg_fail(1)) SWIG_fail;
42296 {
42297 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42298 if (SWIG_arg_fail(2)) SWIG_fail;
42299 }
42300 {
42301 arg3 = &temp3;
42302 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42303 }
42304 {
42305 PyThreadState* __tstate = wxPyBeginAllowThreads();
42306 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42307
42308 wxPyEndAllowThreads(__tstate);
42309 if (PyErr_Occurred()) SWIG_fail;
42310 }
42311 {
42312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42313 }
42314 return resultobj;
42315 fail:
42316 return NULL;
42317 }
42318
42319
42320 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42321 int argc;
42322 PyObject *argv[4];
42323 int ii;
42324
42325 argc = PyObject_Length(args);
42326 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42327 argv[ii] = PyTuple_GetItem(args,ii);
42328 }
42329 if (argc == 3) {
42330 int _v;
42331 {
42332 void *ptr;
42333 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42334 _v = 0;
42335 PyErr_Clear();
42336 } else {
42337 _v = 1;
42338 }
42339 }
42340 if (_v) {
42341 {
42342 void *ptr;
42343 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42344 _v = 0;
42345 PyErr_Clear();
42346 } else {
42347 _v = 1;
42348 }
42349 }
42350 if (_v) {
42351 {
42352 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42353 }
42354 if (_v) {
42355 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42356 }
42357 }
42358 }
42359 }
42360 if (argc == 3) {
42361 int _v;
42362 {
42363 void *ptr;
42364 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42365 _v = 0;
42366 PyErr_Clear();
42367 } else {
42368 _v = 1;
42369 }
42370 }
42371 if (_v) {
42372 {
42373 void *ptr;
42374 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42375 _v = 0;
42376 PyErr_Clear();
42377 } else {
42378 _v = 1;
42379 }
42380 }
42381 if (_v) {
42382 {
42383 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42384 }
42385 if (_v) {
42386 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42387 }
42388 }
42389 }
42390 }
42391 if (argc == 3) {
42392 int _v;
42393 {
42394 void *ptr;
42395 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42396 _v = 0;
42397 PyErr_Clear();
42398 } else {
42399 _v = 1;
42400 }
42401 }
42402 if (_v) {
42403 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42404 if (_v) {
42405 {
42406 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42407 }
42408 if (_v) {
42409 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42410 }
42411 }
42412 }
42413 }
42414
42415 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42416 return NULL;
42417 }
42418
42419
42420 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42421 PyObject *resultobj;
42422 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42423 wxWindow *arg2 = (wxWindow *) 0 ;
42424 wxGBSizerItem *result;
42425 PyObject * obj0 = 0 ;
42426 PyObject * obj1 = 0 ;
42427
42428 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42430 if (SWIG_arg_fail(1)) SWIG_fail;
42431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42432 if (SWIG_arg_fail(2)) SWIG_fail;
42433 {
42434 PyThreadState* __tstate = wxPyBeginAllowThreads();
42435 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42436
42437 wxPyEndAllowThreads(__tstate);
42438 if (PyErr_Occurred()) SWIG_fail;
42439 }
42440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42448 PyObject *resultobj;
42449 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42450 wxSizer *arg2 = (wxSizer *) 0 ;
42451 wxGBSizerItem *result;
42452 PyObject * obj0 = 0 ;
42453 PyObject * obj1 = 0 ;
42454
42455 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42457 if (SWIG_arg_fail(1)) SWIG_fail;
42458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42459 if (SWIG_arg_fail(2)) SWIG_fail;
42460 {
42461 PyThreadState* __tstate = wxPyBeginAllowThreads();
42462 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42463
42464 wxPyEndAllowThreads(__tstate);
42465 if (PyErr_Occurred()) SWIG_fail;
42466 }
42467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42468 return resultobj;
42469 fail:
42470 return NULL;
42471 }
42472
42473
42474 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42475 int argc;
42476 PyObject *argv[3];
42477 int ii;
42478
42479 argc = PyObject_Length(args);
42480 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42481 argv[ii] = PyTuple_GetItem(args,ii);
42482 }
42483 if (argc == 2) {
42484 int _v;
42485 {
42486 void *ptr;
42487 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42488 _v = 0;
42489 PyErr_Clear();
42490 } else {
42491 _v = 1;
42492 }
42493 }
42494 if (_v) {
42495 {
42496 void *ptr;
42497 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42498 _v = 0;
42499 PyErr_Clear();
42500 } else {
42501 _v = 1;
42502 }
42503 }
42504 if (_v) {
42505 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42506 }
42507 }
42508 }
42509 if (argc == 2) {
42510 int _v;
42511 {
42512 void *ptr;
42513 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42514 _v = 0;
42515 PyErr_Clear();
42516 } else {
42517 _v = 1;
42518 }
42519 }
42520 if (_v) {
42521 {
42522 void *ptr;
42523 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42524 _v = 0;
42525 PyErr_Clear();
42526 } else {
42527 _v = 1;
42528 }
42529 }
42530 if (_v) {
42531 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42532 }
42533 }
42534 }
42535
42536 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42537 return NULL;
42538 }
42539
42540
42541 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj;
42543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42544 wxGBPosition *arg2 = 0 ;
42545 wxGBSizerItem *result;
42546 wxGBPosition temp2 ;
42547 PyObject * obj0 = 0 ;
42548 PyObject * obj1 = 0 ;
42549 char *kwnames[] = {
42550 (char *) "self",(char *) "pos", NULL
42551 };
42552
42553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42555 if (SWIG_arg_fail(1)) SWIG_fail;
42556 {
42557 arg2 = &temp2;
42558 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42559 }
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42563
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42568 return resultobj;
42569 fail:
42570 return NULL;
42571 }
42572
42573
42574 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42575 PyObject *resultobj;
42576 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42577 wxPoint *arg2 = 0 ;
42578 wxGBSizerItem *result;
42579 wxPoint temp2 ;
42580 PyObject * obj0 = 0 ;
42581 PyObject * obj1 = 0 ;
42582 char *kwnames[] = {
42583 (char *) "self",(char *) "pt", NULL
42584 };
42585
42586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42588 if (SWIG_arg_fail(1)) SWIG_fail;
42589 {
42590 arg2 = &temp2;
42591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42592 }
42593 {
42594 PyThreadState* __tstate = wxPyBeginAllowThreads();
42595 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42596
42597 wxPyEndAllowThreads(__tstate);
42598 if (PyErr_Occurred()) SWIG_fail;
42599 }
42600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42601 return resultobj;
42602 fail:
42603 return NULL;
42604 }
42605
42606
42607 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42608 PyObject *resultobj;
42609 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42610 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42611 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42612 bool result;
42613 PyObject * obj0 = 0 ;
42614 PyObject * obj1 = 0 ;
42615 PyObject * obj2 = 0 ;
42616 char *kwnames[] = {
42617 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42618 };
42619
42620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42622 if (SWIG_arg_fail(1)) SWIG_fail;
42623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42624 if (SWIG_arg_fail(2)) SWIG_fail;
42625 if (obj2) {
42626 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42627 if (SWIG_arg_fail(3)) SWIG_fail;
42628 }
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42632
42633 wxPyEndAllowThreads(__tstate);
42634 if (PyErr_Occurred()) SWIG_fail;
42635 }
42636 {
42637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42638 }
42639 return resultobj;
42640 fail:
42641 return NULL;
42642 }
42643
42644
42645 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42646 PyObject *resultobj;
42647 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42648 wxGBPosition *arg2 = 0 ;
42649 wxGBSpan *arg3 = 0 ;
42650 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42651 bool result;
42652 wxGBPosition temp2 ;
42653 wxGBSpan temp3 ;
42654 PyObject * obj0 = 0 ;
42655 PyObject * obj1 = 0 ;
42656 PyObject * obj2 = 0 ;
42657 PyObject * obj3 = 0 ;
42658 char *kwnames[] = {
42659 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42660 };
42661
42662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42664 if (SWIG_arg_fail(1)) SWIG_fail;
42665 {
42666 arg2 = &temp2;
42667 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42668 }
42669 {
42670 arg3 = &temp3;
42671 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42672 }
42673 if (obj3) {
42674 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42675 if (SWIG_arg_fail(4)) SWIG_fail;
42676 }
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42680
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 {
42685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42686 }
42687 return resultobj;
42688 fail:
42689 return NULL;
42690 }
42691
42692
42693 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42694 PyObject *obj;
42695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42696 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42697 Py_INCREF(obj);
42698 return Py_BuildValue((char *)"");
42699 }
42700 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42701 PyObject *resultobj;
42702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42703 wxRelationship arg2 ;
42704 wxWindow *arg3 = (wxWindow *) 0 ;
42705 wxEdge arg4 ;
42706 int arg5 = (int) 0 ;
42707 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42708 PyObject * obj0 = 0 ;
42709 PyObject * obj1 = 0 ;
42710 PyObject * obj2 = 0 ;
42711 PyObject * obj3 = 0 ;
42712 PyObject * obj4 = 0 ;
42713 PyObject * obj5 = 0 ;
42714 char *kwnames[] = {
42715 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42716 };
42717
42718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42720 if (SWIG_arg_fail(1)) SWIG_fail;
42721 {
42722 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42723 if (SWIG_arg_fail(2)) SWIG_fail;
42724 }
42725 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42726 if (SWIG_arg_fail(3)) SWIG_fail;
42727 {
42728 arg4 = (wxEdge)(SWIG_As_int(obj3));
42729 if (SWIG_arg_fail(4)) SWIG_fail;
42730 }
42731 if (obj4) {
42732 {
42733 arg5 = (int)(SWIG_As_int(obj4));
42734 if (SWIG_arg_fail(5)) SWIG_fail;
42735 }
42736 }
42737 if (obj5) {
42738 {
42739 arg6 = (int)(SWIG_As_int(obj5));
42740 if (SWIG_arg_fail(6)) SWIG_fail;
42741 }
42742 }
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42746
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 Py_INCREF(Py_None); resultobj = Py_None;
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj;
42759 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42760 wxWindow *arg2 = (wxWindow *) 0 ;
42761 int arg3 = (int) 0 ;
42762 PyObject * obj0 = 0 ;
42763 PyObject * obj1 = 0 ;
42764 PyObject * obj2 = 0 ;
42765 char *kwnames[] = {
42766 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42767 };
42768
42769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42771 if (SWIG_arg_fail(1)) SWIG_fail;
42772 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42773 if (SWIG_arg_fail(2)) SWIG_fail;
42774 if (obj2) {
42775 {
42776 arg3 = (int)(SWIG_As_int(obj2));
42777 if (SWIG_arg_fail(3)) SWIG_fail;
42778 }
42779 }
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 (arg1)->LeftOf(arg2,arg3);
42783
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 Py_INCREF(Py_None); resultobj = Py_None;
42788 return resultobj;
42789 fail:
42790 return NULL;
42791 }
42792
42793
42794 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42795 PyObject *resultobj;
42796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42797 wxWindow *arg2 = (wxWindow *) 0 ;
42798 int arg3 = (int) 0 ;
42799 PyObject * obj0 = 0 ;
42800 PyObject * obj1 = 0 ;
42801 PyObject * obj2 = 0 ;
42802 char *kwnames[] = {
42803 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42804 };
42805
42806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42808 if (SWIG_arg_fail(1)) SWIG_fail;
42809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42810 if (SWIG_arg_fail(2)) SWIG_fail;
42811 if (obj2) {
42812 {
42813 arg3 = (int)(SWIG_As_int(obj2));
42814 if (SWIG_arg_fail(3)) SWIG_fail;
42815 }
42816 }
42817 {
42818 PyThreadState* __tstate = wxPyBeginAllowThreads();
42819 (arg1)->RightOf(arg2,arg3);
42820
42821 wxPyEndAllowThreads(__tstate);
42822 if (PyErr_Occurred()) SWIG_fail;
42823 }
42824 Py_INCREF(Py_None); resultobj = Py_None;
42825 return resultobj;
42826 fail:
42827 return NULL;
42828 }
42829
42830
42831 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
42832 PyObject *resultobj;
42833 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42834 wxWindow *arg2 = (wxWindow *) 0 ;
42835 int arg3 = (int) 0 ;
42836 PyObject * obj0 = 0 ;
42837 PyObject * obj1 = 0 ;
42838 PyObject * obj2 = 0 ;
42839 char *kwnames[] = {
42840 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42841 };
42842
42843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
42844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42845 if (SWIG_arg_fail(1)) SWIG_fail;
42846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42847 if (SWIG_arg_fail(2)) SWIG_fail;
42848 if (obj2) {
42849 {
42850 arg3 = (int)(SWIG_As_int(obj2));
42851 if (SWIG_arg_fail(3)) SWIG_fail;
42852 }
42853 }
42854 {
42855 PyThreadState* __tstate = wxPyBeginAllowThreads();
42856 (arg1)->Above(arg2,arg3);
42857
42858 wxPyEndAllowThreads(__tstate);
42859 if (PyErr_Occurred()) SWIG_fail;
42860 }
42861 Py_INCREF(Py_None); resultobj = Py_None;
42862 return resultobj;
42863 fail:
42864 return NULL;
42865 }
42866
42867
42868 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
42869 PyObject *resultobj;
42870 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42871 wxWindow *arg2 = (wxWindow *) 0 ;
42872 int arg3 = (int) 0 ;
42873 PyObject * obj0 = 0 ;
42874 PyObject * obj1 = 0 ;
42875 PyObject * obj2 = 0 ;
42876 char *kwnames[] = {
42877 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42878 };
42879
42880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
42881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42882 if (SWIG_arg_fail(1)) SWIG_fail;
42883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42884 if (SWIG_arg_fail(2)) SWIG_fail;
42885 if (obj2) {
42886 {
42887 arg3 = (int)(SWIG_As_int(obj2));
42888 if (SWIG_arg_fail(3)) SWIG_fail;
42889 }
42890 }
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 (arg1)->Below(arg2,arg3);
42894
42895 wxPyEndAllowThreads(__tstate);
42896 if (PyErr_Occurred()) SWIG_fail;
42897 }
42898 Py_INCREF(Py_None); resultobj = Py_None;
42899 return resultobj;
42900 fail:
42901 return NULL;
42902 }
42903
42904
42905 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
42906 PyObject *resultobj;
42907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42908 wxWindow *arg2 = (wxWindow *) 0 ;
42909 wxEdge arg3 ;
42910 int arg4 = (int) 0 ;
42911 PyObject * obj0 = 0 ;
42912 PyObject * obj1 = 0 ;
42913 PyObject * obj2 = 0 ;
42914 PyObject * obj3 = 0 ;
42915 char *kwnames[] = {
42916 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
42917 };
42918
42919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42921 if (SWIG_arg_fail(1)) SWIG_fail;
42922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42923 if (SWIG_arg_fail(2)) SWIG_fail;
42924 {
42925 arg3 = (wxEdge)(SWIG_As_int(obj2));
42926 if (SWIG_arg_fail(3)) SWIG_fail;
42927 }
42928 if (obj3) {
42929 {
42930 arg4 = (int)(SWIG_As_int(obj3));
42931 if (SWIG_arg_fail(4)) SWIG_fail;
42932 }
42933 }
42934 {
42935 PyThreadState* __tstate = wxPyBeginAllowThreads();
42936 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
42937
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 Py_INCREF(Py_None); resultobj = Py_None;
42942 return resultobj;
42943 fail:
42944 return NULL;
42945 }
42946
42947
42948 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
42949 PyObject *resultobj;
42950 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42951 wxWindow *arg2 = (wxWindow *) 0 ;
42952 wxEdge arg3 ;
42953 int arg4 ;
42954 PyObject * obj0 = 0 ;
42955 PyObject * obj1 = 0 ;
42956 PyObject * obj2 = 0 ;
42957 PyObject * obj3 = 0 ;
42958 char *kwnames[] = {
42959 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
42960 };
42961
42962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42964 if (SWIG_arg_fail(1)) SWIG_fail;
42965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42966 if (SWIG_arg_fail(2)) SWIG_fail;
42967 {
42968 arg3 = (wxEdge)(SWIG_As_int(obj2));
42969 if (SWIG_arg_fail(3)) SWIG_fail;
42970 }
42971 {
42972 arg4 = (int)(SWIG_As_int(obj3));
42973 if (SWIG_arg_fail(4)) SWIG_fail;
42974 }
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
42978
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 Py_INCREF(Py_None); resultobj = Py_None;
42983 return resultobj;
42984 fail:
42985 return NULL;
42986 }
42987
42988
42989 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
42990 PyObject *resultobj;
42991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42992 int arg2 ;
42993 PyObject * obj0 = 0 ;
42994 PyObject * obj1 = 0 ;
42995 char *kwnames[] = {
42996 (char *) "self",(char *) "val", NULL
42997 };
42998
42999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43001 if (SWIG_arg_fail(1)) SWIG_fail;
43002 {
43003 arg2 = (int)(SWIG_As_int(obj1));
43004 if (SWIG_arg_fail(2)) SWIG_fail;
43005 }
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 (arg1)->Absolute(arg2);
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 Py_INCREF(Py_None); resultobj = Py_None;
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj;
43022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43023 PyObject * obj0 = 0 ;
43024 char *kwnames[] = {
43025 (char *) "self", NULL
43026 };
43027
43028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43030 if (SWIG_arg_fail(1)) SWIG_fail;
43031 {
43032 PyThreadState* __tstate = wxPyBeginAllowThreads();
43033 (arg1)->Unconstrained();
43034
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 Py_INCREF(Py_None); resultobj = Py_None;
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj;
43047 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43048 PyObject * obj0 = 0 ;
43049 char *kwnames[] = {
43050 (char *) "self", NULL
43051 };
43052
43053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43055 if (SWIG_arg_fail(1)) SWIG_fail;
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 (arg1)->AsIs();
43059
43060 wxPyEndAllowThreads(__tstate);
43061 if (PyErr_Occurred()) SWIG_fail;
43062 }
43063 Py_INCREF(Py_None); resultobj = Py_None;
43064 return resultobj;
43065 fail:
43066 return NULL;
43067 }
43068
43069
43070 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43071 PyObject *resultobj;
43072 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43073 wxWindow *result;
43074 PyObject * obj0 = 0 ;
43075 char *kwnames[] = {
43076 (char *) "self", NULL
43077 };
43078
43079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43081 if (SWIG_arg_fail(1)) SWIG_fail;
43082 {
43083 PyThreadState* __tstate = wxPyBeginAllowThreads();
43084 result = (wxWindow *)(arg1)->GetOtherWindow();
43085
43086 wxPyEndAllowThreads(__tstate);
43087 if (PyErr_Occurred()) SWIG_fail;
43088 }
43089 {
43090 resultobj = wxPyMake_wxObject(result, 0);
43091 }
43092 return resultobj;
43093 fail:
43094 return NULL;
43095 }
43096
43097
43098 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43099 PyObject *resultobj;
43100 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43101 wxEdge result;
43102 PyObject * obj0 = 0 ;
43103 char *kwnames[] = {
43104 (char *) "self", NULL
43105 };
43106
43107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(1)) SWIG_fail;
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43113
43114 wxPyEndAllowThreads(__tstate);
43115 if (PyErr_Occurred()) SWIG_fail;
43116 }
43117 resultobj = SWIG_From_int((result));
43118 return resultobj;
43119 fail:
43120 return NULL;
43121 }
43122
43123
43124 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43125 PyObject *resultobj;
43126 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43127 wxEdge arg2 ;
43128 PyObject * obj0 = 0 ;
43129 PyObject * obj1 = 0 ;
43130 char *kwnames[] = {
43131 (char *) "self",(char *) "which", NULL
43132 };
43133
43134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43136 if (SWIG_arg_fail(1)) SWIG_fail;
43137 {
43138 arg2 = (wxEdge)(SWIG_As_int(obj1));
43139 if (SWIG_arg_fail(2)) SWIG_fail;
43140 }
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 (arg1)->SetEdge((wxEdge )arg2);
43144
43145 wxPyEndAllowThreads(__tstate);
43146 if (PyErr_Occurred()) SWIG_fail;
43147 }
43148 Py_INCREF(Py_None); resultobj = Py_None;
43149 return resultobj;
43150 fail:
43151 return NULL;
43152 }
43153
43154
43155 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43156 PyObject *resultobj;
43157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43158 int arg2 ;
43159 PyObject * obj0 = 0 ;
43160 PyObject * obj1 = 0 ;
43161 char *kwnames[] = {
43162 (char *) "self",(char *) "v", NULL
43163 };
43164
43165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43167 if (SWIG_arg_fail(1)) SWIG_fail;
43168 {
43169 arg2 = (int)(SWIG_As_int(obj1));
43170 if (SWIG_arg_fail(2)) SWIG_fail;
43171 }
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 (arg1)->SetValue(arg2);
43175
43176 wxPyEndAllowThreads(__tstate);
43177 if (PyErr_Occurred()) SWIG_fail;
43178 }
43179 Py_INCREF(Py_None); resultobj = Py_None;
43180 return resultobj;
43181 fail:
43182 return NULL;
43183 }
43184
43185
43186 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43187 PyObject *resultobj;
43188 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43189 int result;
43190 PyObject * obj0 = 0 ;
43191 char *kwnames[] = {
43192 (char *) "self", NULL
43193 };
43194
43195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43197 if (SWIG_arg_fail(1)) SWIG_fail;
43198 {
43199 PyThreadState* __tstate = wxPyBeginAllowThreads();
43200 result = (int)(arg1)->GetMargin();
43201
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 {
43206 resultobj = SWIG_From_int((int)(result));
43207 }
43208 return resultobj;
43209 fail:
43210 return NULL;
43211 }
43212
43213
43214 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43215 PyObject *resultobj;
43216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43217 int arg2 ;
43218 PyObject * obj0 = 0 ;
43219 PyObject * obj1 = 0 ;
43220 char *kwnames[] = {
43221 (char *) "self",(char *) "m", NULL
43222 };
43223
43224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43226 if (SWIG_arg_fail(1)) SWIG_fail;
43227 {
43228 arg2 = (int)(SWIG_As_int(obj1));
43229 if (SWIG_arg_fail(2)) SWIG_fail;
43230 }
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 (arg1)->SetMargin(arg2);
43234
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 Py_INCREF(Py_None); resultobj = Py_None;
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43246 PyObject *resultobj;
43247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43248 int result;
43249 PyObject * obj0 = 0 ;
43250 char *kwnames[] = {
43251 (char *) "self", NULL
43252 };
43253
43254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43256 if (SWIG_arg_fail(1)) SWIG_fail;
43257 {
43258 PyThreadState* __tstate = wxPyBeginAllowThreads();
43259 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43260
43261 wxPyEndAllowThreads(__tstate);
43262 if (PyErr_Occurred()) SWIG_fail;
43263 }
43264 {
43265 resultobj = SWIG_From_int((int)(result));
43266 }
43267 return resultobj;
43268 fail:
43269 return NULL;
43270 }
43271
43272
43273 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43274 PyObject *resultobj;
43275 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43276 int result;
43277 PyObject * obj0 = 0 ;
43278 char *kwnames[] = {
43279 (char *) "self", NULL
43280 };
43281
43282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43284 if (SWIG_arg_fail(1)) SWIG_fail;
43285 {
43286 PyThreadState* __tstate = wxPyBeginAllowThreads();
43287 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43288
43289 wxPyEndAllowThreads(__tstate);
43290 if (PyErr_Occurred()) SWIG_fail;
43291 }
43292 {
43293 resultobj = SWIG_From_int((int)(result));
43294 }
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43302 PyObject *resultobj;
43303 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43304 int result;
43305 PyObject * obj0 = 0 ;
43306 char *kwnames[] = {
43307 (char *) "self", NULL
43308 };
43309
43310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43312 if (SWIG_arg_fail(1)) SWIG_fail;
43313 {
43314 PyThreadState* __tstate = wxPyBeginAllowThreads();
43315 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43316
43317 wxPyEndAllowThreads(__tstate);
43318 if (PyErr_Occurred()) SWIG_fail;
43319 }
43320 {
43321 resultobj = SWIG_From_int((int)(result));
43322 }
43323 return resultobj;
43324 fail:
43325 return NULL;
43326 }
43327
43328
43329 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43330 PyObject *resultobj;
43331 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43332 bool result;
43333 PyObject * obj0 = 0 ;
43334 char *kwnames[] = {
43335 (char *) "self", NULL
43336 };
43337
43338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43340 if (SWIG_arg_fail(1)) SWIG_fail;
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43344
43345 wxPyEndAllowThreads(__tstate);
43346 if (PyErr_Occurred()) SWIG_fail;
43347 }
43348 {
43349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43350 }
43351 return resultobj;
43352 fail:
43353 return NULL;
43354 }
43355
43356
43357 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43358 PyObject *resultobj;
43359 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43360 bool arg2 ;
43361 PyObject * obj0 = 0 ;
43362 PyObject * obj1 = 0 ;
43363 char *kwnames[] = {
43364 (char *) "self",(char *) "d", NULL
43365 };
43366
43367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43369 if (SWIG_arg_fail(1)) SWIG_fail;
43370 {
43371 arg2 = (bool)(SWIG_As_bool(obj1));
43372 if (SWIG_arg_fail(2)) SWIG_fail;
43373 }
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 (arg1)->SetDone(arg2);
43377
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 Py_INCREF(Py_None); resultobj = Py_None;
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43389 PyObject *resultobj;
43390 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43391 wxRelationship result;
43392 PyObject * obj0 = 0 ;
43393 char *kwnames[] = {
43394 (char *) "self", NULL
43395 };
43396
43397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43399 if (SWIG_arg_fail(1)) SWIG_fail;
43400 {
43401 PyThreadState* __tstate = wxPyBeginAllowThreads();
43402 result = (wxRelationship)(arg1)->GetRelationship();
43403
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 resultobj = SWIG_From_int((result));
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43415 PyObject *resultobj;
43416 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43417 wxRelationship arg2 ;
43418 PyObject * obj0 = 0 ;
43419 PyObject * obj1 = 0 ;
43420 char *kwnames[] = {
43421 (char *) "self",(char *) "r", NULL
43422 };
43423
43424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43426 if (SWIG_arg_fail(1)) SWIG_fail;
43427 {
43428 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43429 if (SWIG_arg_fail(2)) SWIG_fail;
43430 }
43431 {
43432 PyThreadState* __tstate = wxPyBeginAllowThreads();
43433 (arg1)->SetRelationship((wxRelationship )arg2);
43434
43435 wxPyEndAllowThreads(__tstate);
43436 if (PyErr_Occurred()) SWIG_fail;
43437 }
43438 Py_INCREF(Py_None); resultobj = Py_None;
43439 return resultobj;
43440 fail:
43441 return NULL;
43442 }
43443
43444
43445 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43446 PyObject *resultobj;
43447 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43448 wxWindow *arg2 = (wxWindow *) 0 ;
43449 bool result;
43450 PyObject * obj0 = 0 ;
43451 PyObject * obj1 = 0 ;
43452 char *kwnames[] = {
43453 (char *) "self",(char *) "otherW", NULL
43454 };
43455
43456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43458 if (SWIG_arg_fail(1)) SWIG_fail;
43459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43460 if (SWIG_arg_fail(2)) SWIG_fail;
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (bool)(arg1)->ResetIfWin(arg2);
43464
43465 wxPyEndAllowThreads(__tstate);
43466 if (PyErr_Occurred()) SWIG_fail;
43467 }
43468 {
43469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43470 }
43471 return resultobj;
43472 fail:
43473 return NULL;
43474 }
43475
43476
43477 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43478 PyObject *resultobj;
43479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43480 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43481 wxWindow *arg3 = (wxWindow *) 0 ;
43482 bool result;
43483 PyObject * obj0 = 0 ;
43484 PyObject * obj1 = 0 ;
43485 PyObject * obj2 = 0 ;
43486 char *kwnames[] = {
43487 (char *) "self",(char *) "constraints",(char *) "win", NULL
43488 };
43489
43490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43492 if (SWIG_arg_fail(1)) SWIG_fail;
43493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43494 if (SWIG_arg_fail(2)) SWIG_fail;
43495 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43496 if (SWIG_arg_fail(3)) SWIG_fail;
43497 {
43498 PyThreadState* __tstate = wxPyBeginAllowThreads();
43499 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43500
43501 wxPyEndAllowThreads(__tstate);
43502 if (PyErr_Occurred()) SWIG_fail;
43503 }
43504 {
43505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43506 }
43507 return resultobj;
43508 fail:
43509 return NULL;
43510 }
43511
43512
43513 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43514 PyObject *resultobj;
43515 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43516 wxEdge arg2 ;
43517 wxWindow *arg3 = (wxWindow *) 0 ;
43518 wxWindow *arg4 = (wxWindow *) 0 ;
43519 int result;
43520 PyObject * obj0 = 0 ;
43521 PyObject * obj1 = 0 ;
43522 PyObject * obj2 = 0 ;
43523 PyObject * obj3 = 0 ;
43524 char *kwnames[] = {
43525 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43526 };
43527
43528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43530 if (SWIG_arg_fail(1)) SWIG_fail;
43531 {
43532 arg2 = (wxEdge)(SWIG_As_int(obj1));
43533 if (SWIG_arg_fail(2)) SWIG_fail;
43534 }
43535 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43536 if (SWIG_arg_fail(3)) SWIG_fail;
43537 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43538 if (SWIG_arg_fail(4)) SWIG_fail;
43539 {
43540 PyThreadState* __tstate = wxPyBeginAllowThreads();
43541 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43542
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 {
43547 resultobj = SWIG_From_int((int)(result));
43548 }
43549 return resultobj;
43550 fail:
43551 return NULL;
43552 }
43553
43554
43555 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43556 PyObject *obj;
43557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43558 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43559 Py_INCREF(obj);
43560 return Py_BuildValue((char *)"");
43561 }
43562 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43563 PyObject *resultobj;
43564 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43565 wxIndividualLayoutConstraint *result;
43566 PyObject * obj0 = 0 ;
43567 char *kwnames[] = {
43568 (char *) "self", NULL
43569 };
43570
43571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43573 if (SWIG_arg_fail(1)) SWIG_fail;
43574 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43575
43576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43577 return resultobj;
43578 fail:
43579 return NULL;
43580 }
43581
43582
43583 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43584 PyObject *resultobj;
43585 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43586 wxIndividualLayoutConstraint *result;
43587 PyObject * obj0 = 0 ;
43588 char *kwnames[] = {
43589 (char *) "self", NULL
43590 };
43591
43592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43594 if (SWIG_arg_fail(1)) SWIG_fail;
43595 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43596
43597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43598 return resultobj;
43599 fail:
43600 return NULL;
43601 }
43602
43603
43604 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43605 PyObject *resultobj;
43606 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43607 wxIndividualLayoutConstraint *result;
43608 PyObject * obj0 = 0 ;
43609 char *kwnames[] = {
43610 (char *) "self", NULL
43611 };
43612
43613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43615 if (SWIG_arg_fail(1)) SWIG_fail;
43616 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43617
43618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43619 return resultobj;
43620 fail:
43621 return NULL;
43622 }
43623
43624
43625 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43626 PyObject *resultobj;
43627 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43628 wxIndividualLayoutConstraint *result;
43629 PyObject * obj0 = 0 ;
43630 char *kwnames[] = {
43631 (char *) "self", NULL
43632 };
43633
43634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43636 if (SWIG_arg_fail(1)) SWIG_fail;
43637 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43638
43639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43647 PyObject *resultobj;
43648 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43649 wxIndividualLayoutConstraint *result;
43650 PyObject * obj0 = 0 ;
43651 char *kwnames[] = {
43652 (char *) "self", NULL
43653 };
43654
43655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43657 if (SWIG_arg_fail(1)) SWIG_fail;
43658 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43659
43660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43661 return resultobj;
43662 fail:
43663 return NULL;
43664 }
43665
43666
43667 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43668 PyObject *resultobj;
43669 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43670 wxIndividualLayoutConstraint *result;
43671 PyObject * obj0 = 0 ;
43672 char *kwnames[] = {
43673 (char *) "self", NULL
43674 };
43675
43676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43678 if (SWIG_arg_fail(1)) SWIG_fail;
43679 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43680
43681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43682 return resultobj;
43683 fail:
43684 return NULL;
43685 }
43686
43687
43688 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj;
43690 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43691 wxIndividualLayoutConstraint *result;
43692 PyObject * obj0 = 0 ;
43693 char *kwnames[] = {
43694 (char *) "self", NULL
43695 };
43696
43697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43699 if (SWIG_arg_fail(1)) SWIG_fail;
43700 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43701
43702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43710 PyObject *resultobj;
43711 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43712 wxIndividualLayoutConstraint *result;
43713 PyObject * obj0 = 0 ;
43714 char *kwnames[] = {
43715 (char *) "self", NULL
43716 };
43717
43718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43720 if (SWIG_arg_fail(1)) SWIG_fail;
43721 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43722
43723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43724 return resultobj;
43725 fail:
43726 return NULL;
43727 }
43728
43729
43730 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43731 PyObject *resultobj;
43732 wxLayoutConstraints *result;
43733 char *kwnames[] = {
43734 NULL
43735 };
43736
43737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43741
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43746 return resultobj;
43747 fail:
43748 return NULL;
43749 }
43750
43751
43752 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43753 PyObject *resultobj;
43754 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43755 wxWindow *arg2 = (wxWindow *) 0 ;
43756 int *arg3 = (int *) 0 ;
43757 bool result;
43758 int temp3 ;
43759 int res3 = 0 ;
43760 PyObject * obj0 = 0 ;
43761 PyObject * obj1 = 0 ;
43762 char *kwnames[] = {
43763 (char *) "self",(char *) "win", NULL
43764 };
43765
43766 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43769 if (SWIG_arg_fail(1)) SWIG_fail;
43770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43771 if (SWIG_arg_fail(2)) SWIG_fail;
43772 {
43773 PyThreadState* __tstate = wxPyBeginAllowThreads();
43774 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43775
43776 wxPyEndAllowThreads(__tstate);
43777 if (PyErr_Occurred()) SWIG_fail;
43778 }
43779 {
43780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43781 }
43782 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43783 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43784 return resultobj;
43785 fail:
43786 return NULL;
43787 }
43788
43789
43790 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43791 PyObject *resultobj;
43792 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43793 bool result;
43794 PyObject * obj0 = 0 ;
43795 char *kwnames[] = {
43796 (char *) "self", NULL
43797 };
43798
43799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43801 if (SWIG_arg_fail(1)) SWIG_fail;
43802 {
43803 PyThreadState* __tstate = wxPyBeginAllowThreads();
43804 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43805
43806 wxPyEndAllowThreads(__tstate);
43807 if (PyErr_Occurred()) SWIG_fail;
43808 }
43809 {
43810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43811 }
43812 return resultobj;
43813 fail:
43814 return NULL;
43815 }
43816
43817
43818 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
43819 PyObject *obj;
43820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43821 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
43822 Py_INCREF(obj);
43823 return Py_BuildValue((char *)"");
43824 }
43825 static PyMethodDef SwigMethods[] = {
43826 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
43827 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
43828 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
43829 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43830 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
43831 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43832 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43833 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43834 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43835 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43836 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43837 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43838 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43839 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43840 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43841 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
43842 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
43843 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43844 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43845 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43846 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43847 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43848 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
43849 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
43850 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43851 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
43852 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43853 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43854 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43855 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43856 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43857 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43858 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43859 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43860 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43861 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43862 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43863 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43864 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
43865 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43866 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43867 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43868 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43869 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43870 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43871 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43872 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43873 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43874 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43875 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43876 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43877 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43878 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43879 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
43880 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43881 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
43882 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
43883 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
43884 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43885 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43886 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
43887 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43888 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
43889 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43890 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43891 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43892 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43893 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43894 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43895 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43896 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43897 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43898 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43899 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43900 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43901 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43902 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43903 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43904 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43905 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43906 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43907 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43908 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43909 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
43910 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
43911 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
43912 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
43913 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
43914 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
43915 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43916 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43917 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43918 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43919 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
43920 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
43921 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
43922 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43923 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43924 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43925 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43926 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43927 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43928 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43929 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43930 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43931 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43932 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
43933 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
43934 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
43935 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
43936 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43937 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
43938 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
43939 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43940 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43941 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43942 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43943 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
43944 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
43945 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43946 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43947 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
43948 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43949 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43950 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
43951 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
43952 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43953 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43954 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43955 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43956 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43957 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43958 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43959 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43960 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
43961 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43962 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43963 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
43964 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
43965 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
43966 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
43967 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
43968 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
43969 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
43970 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
43971 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
43972 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
43973 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
43974 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43975 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
43976 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
43977 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
43978 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
43979 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
43980 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
43981 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
43982 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43983 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43984 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
43985 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43986 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43987 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43988 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
43989 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
43990 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
43991 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43992 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
43993 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43994 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43995 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43996 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43997 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
43998 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43999 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44000 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44001 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44002 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44003 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44004 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44005 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44006 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44007 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44008 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44009 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44010 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44011 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44012 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44013 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44014 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44015 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44016 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44017 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44019 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44020 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44023 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44024 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44025 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44027 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44034 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44035 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44037 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44041 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44045 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44049 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44051 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44054 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44069 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44070 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44072 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44080 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44081 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44090 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44094 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44104 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44109 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44114 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44115 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44122 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44123 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44125 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44127 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44129 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44131 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44133 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44135 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44137 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44139 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44141 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44143 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44145 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44147 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44154 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44157 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44161 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44179 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44182 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44185 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44197 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44202 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44208 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44214 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44277 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44284 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44320 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44330 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44336 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44338 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44340 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44343 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44347 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44350 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44353 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44355 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44360 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44368 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44372 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44375 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44377 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44381 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44398 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44400 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44403 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44405 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44409 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44413 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44422 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44425 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44428 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44432 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44439 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44444 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44449 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44494 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44514 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44521 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44525 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44535 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44705 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44745 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44759 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44762 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
44817 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
44844 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
44874 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
44882 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
44899 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
44900 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
44937 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
44967 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
44970 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
44974 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
44977 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
44987 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
44999 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45011 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45021 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45031 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45045 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45052 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45053 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45054 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45055 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45056 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45061 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45088 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45100 { NULL, NULL, 0, NULL }
45101 };
45102
45103
45104 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45105
45106 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45107 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45108 }
45109 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45110 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45111 }
45112 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45113 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45114 }
45115 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45116 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45117 }
45118 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45119 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45120 }
45121 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45122 return (void *)((wxSizer *) ((wxGridSizer *) x));
45123 }
45124 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45125 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45126 }
45127 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45128 return (void *)((wxSizer *) ((wxPySizer *) x));
45129 }
45130 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45131 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45132 }
45133 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45134 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45135 }
45136 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45138 }
45139 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45140 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45141 }
45142 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45143 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45144 }
45145 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45146 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45147 }
45148 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45149 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45150 }
45151 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45152 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45153 }
45154 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45155 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45156 }
45157 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45159 }
45160 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45161 return (void *)((wxEvent *) ((wxPyEvent *) x));
45162 }
45163 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45164 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45165 }
45166 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45167 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45168 }
45169 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45171 }
45172 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45173 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45174 }
45175 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45176 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45177 }
45178 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45179 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45180 }
45181 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45182 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45183 }
45184 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45185 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45186 }
45187 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45188 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45189 }
45190 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45191 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45192 }
45193 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45194 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45195 }
45196 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45197 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45198 }
45199 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45200 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45201 }
45202 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45203 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45204 }
45205 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45206 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45207 }
45208 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45209 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45210 }
45211 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45212 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45213 }
45214 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45215 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45216 }
45217 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45218 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45219 }
45220 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45221 return (void *)((wxEvent *) ((wxShowEvent *) x));
45222 }
45223 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45224 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45225 }
45226 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45227 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45228 }
45229 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45230 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45231 }
45232 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45233 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45234 }
45235 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45236 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45237 }
45238 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45239 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45240 }
45241 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45242 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45243 }
45244 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45245 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45246 }
45247 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45248 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45249 }
45250 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45251 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45252 }
45253 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45254 return (void *)((wxControl *) ((wxControlWithItems *) x));
45255 }
45256 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45257 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45258 }
45259 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45260 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45261 }
45262 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45263 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45264 }
45265 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45266 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45267 }
45268 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45269 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45270 }
45271 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45272 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45273 }
45274 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45275 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45276 }
45277 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45278 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45279 }
45280 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45281 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45282 }
45283 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45284 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45285 }
45286 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45287 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45288 }
45289 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45290 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45291 }
45292 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45293 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45294 }
45295 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45296 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45297 }
45298 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45299 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45300 }
45301 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45302 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45303 }
45304 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45305 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45306 }
45307 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45308 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45309 }
45310 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45311 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45312 }
45313 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45314 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45315 }
45316 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45317 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45318 }
45319 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45320 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45321 }
45322 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45323 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45324 }
45325 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45326 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45327 }
45328 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45329 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45330 }
45331 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45332 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45333 }
45334 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45335 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45336 }
45337 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45338 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45339 }
45340 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45341 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45342 }
45343 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45344 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45345 }
45346 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45347 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45348 }
45349 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45350 return (void *)((wxObject *) ((wxSizerItem *) x));
45351 }
45352 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45354 }
45355 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45356 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45357 }
45358 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45359 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45360 }
45361 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45362 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45363 }
45364 static void *_p_wxSizerTo_p_wxObject(void *x) {
45365 return (void *)((wxObject *) ((wxSizer *) x));
45366 }
45367 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45368 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45369 }
45370 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45371 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45372 }
45373 static void *_p_wxEventTo_p_wxObject(void *x) {
45374 return (void *)((wxObject *) ((wxEvent *) x));
45375 }
45376 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45377 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45378 }
45379 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45380 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45381 }
45382 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45383 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45384 }
45385 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45386 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45387 }
45388 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45389 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45390 }
45391 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45392 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45393 }
45394 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45395 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45396 }
45397 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45398 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45399 }
45400 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45401 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45402 }
45403 static void *_p_wxControlTo_p_wxObject(void *x) {
45404 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45405 }
45406 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45407 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45408 }
45409 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45410 return (void *)((wxObject *) ((wxFSFile *) x));
45411 }
45412 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45413 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45414 }
45415 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45416 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45417 }
45418 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45419 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45420 }
45421 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45422 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45423 }
45424 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45425 return (void *)((wxObject *) ((wxMenuItem *) x));
45426 }
45427 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45428 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45429 }
45430 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45431 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45432 }
45433 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45434 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45435 }
45436 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45437 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45438 }
45439 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45440 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45441 }
45442 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45443 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45444 }
45445 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45446 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45447 }
45448 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45449 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45450 }
45451 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45452 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45453 }
45454 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45455 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45456 }
45457 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45458 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45459 }
45460 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45461 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45462 }
45463 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45464 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45465 }
45466 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45467 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45468 }
45469 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45470 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45471 }
45472 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45473 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45474 }
45475 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45476 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45477 }
45478 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45479 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45480 }
45481 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45482 return (void *)((wxObject *) ((wxImageHandler *) x));
45483 }
45484 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45485 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45486 }
45487 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45488 return (void *)((wxObject *) ((wxEvtHandler *) x));
45489 }
45490 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45491 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45492 }
45493 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45494 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45495 }
45496 static void *_p_wxImageTo_p_wxObject(void *x) {
45497 return (void *)((wxObject *) ((wxImage *) x));
45498 }
45499 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45500 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45501 }
45502 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45504 }
45505 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45506 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45507 }
45508 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45509 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45510 }
45511 static void *_p_wxWindowTo_p_wxObject(void *x) {
45512 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45513 }
45514 static void *_p_wxMenuTo_p_wxObject(void *x) {
45515 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45516 }
45517 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45518 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45519 }
45520 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45521 return (void *)((wxObject *) ((wxFileSystem *) x));
45522 }
45523 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45525 }
45526 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45527 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45528 }
45529 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45530 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45531 }
45532 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45533 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45534 }
45535 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45536 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45537 }
45538 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45539 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45540 }
45541 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45542 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45543 }
45544 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45545 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45546 }
45547 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45548 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45549 }
45550 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45551 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45552 }
45553 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45554 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45555 }
45556 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45557 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45558 }
45559 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45560 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45561 }
45562 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45563 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45564 }
45565 static void *_p_wxControlTo_p_wxWindow(void *x) {
45566 return (void *)((wxWindow *) ((wxControl *) x));
45567 }
45568 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45569 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45570 }
45571 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45572 return (void *)((wxWindow *) ((wxMenuBar *) x));
45573 }
45574 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45575 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45576 }
45577 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45578 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45579 }
45580 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45581 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45582 }
45583 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45584 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45585 }
45586 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45587 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45588 }
45589 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45590 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45591 }
45592 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45593 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45594 }
45595 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45596 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45597 }
45598 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45599 return (void *)((wxValidator *) ((wxPyValidator *) x));
45600 }
45601 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}};
45602 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}};
45603 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}};
45604 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}};
45605 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}};
45606 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}};
45607 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}};
45608 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}};
45609 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}};
45610 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}};
45611 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}};
45612 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}};
45613 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}};
45614 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_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_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_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_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}};
45615 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}};
45616 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}};
45617 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}};
45618 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}};
45619 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}};
45620 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}};
45621 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}};
45622 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}};
45623 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}};
45624 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}};
45625 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}};
45626 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}};
45627 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}};
45628 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}};
45629 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}};
45630 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}};
45631 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}};
45632 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}};
45633 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}};
45634 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}};
45635 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}};
45636 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}};
45637 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}};
45638 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}};
45639 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}};
45640 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}};
45641 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}};
45642 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}};
45643 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}};
45644 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}};
45645 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}};
45646 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}};
45647 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}};
45648 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}};
45649 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}};
45650 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}};
45651 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}};
45652 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}};
45653 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}};
45654 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}};
45655 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}};
45656 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}};
45657 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}};
45658 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}};
45659 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}};
45660 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}};
45661 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}};
45662 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}};
45663 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}};
45664 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}};
45665 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}};
45666 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}};
45667 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}};
45668 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}};
45669 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}};
45670 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}};
45671 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}};
45672 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}};
45673 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}};
45674 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}};
45675 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}};
45676 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}};
45677 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}};
45678 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}};
45679 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}};
45680 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}};
45681 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}};
45682 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}};
45683 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}};
45684 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}};
45685 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}};
45686 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}};
45687 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}};
45688 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}};
45689 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}};
45690 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}};
45691 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}};
45692 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}};
45693 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}};
45694 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_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_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_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}};
45695 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}};
45696 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}};
45697 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}};
45698 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}};
45699 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}};
45700 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}};
45701 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}};
45702 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}};
45703 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}};
45704 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}};
45705 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}};
45706 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}};
45707 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}};
45708 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}};
45709 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}};
45710 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}};
45711 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45712 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}};
45713 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}};
45714 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}};
45715 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}};
45716 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_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}};
45717 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}};
45718 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}};
45719 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}};
45720 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}};
45721 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}};
45722 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}};
45723 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}};
45724 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}};
45725 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}};
45726 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}};
45727
45728 static swig_type_info *swig_types_initial[] = {
45729 _swigt__p_wxLayoutConstraints,
45730 _swigt__p_wxRealPoint,
45731 _swigt__p_wxSizerItem,
45732 _swigt__p_wxGBSizerItem,
45733 _swigt__p_wxScrollEvent,
45734 _swigt__p_wxEventLoop,
45735 _swigt__p_wxIndividualLayoutConstraint,
45736 _swigt__p_wxSizer,
45737 _swigt__p_wxBoxSizer,
45738 _swigt__p_wxStaticBoxSizer,
45739 _swigt__p_wxGridBagSizer,
45740 _swigt__p_wxAcceleratorEntry,
45741 _swigt__p_wxUpdateUIEvent,
45742 _swigt__p_wxEvent,
45743 _swigt__p_wxMenu,
45744 _swigt__p_wxGridSizer,
45745 _swigt__p_wxFlexGridSizer,
45746 _swigt__p_wxInitDialogEvent,
45747 _swigt__p_wxItemContainer,
45748 _swigt__p_wxNcPaintEvent,
45749 _swigt__p_wxPaintEvent,
45750 _swigt__p_wxSysColourChangedEvent,
45751 _swigt__p_wxMouseCaptureChangedEvent,
45752 _swigt__p_wxDisplayChangedEvent,
45753 _swigt__p_wxPaletteChangedEvent,
45754 _swigt__p_wxControl,
45755 _swigt__p_wxFont,
45756 _swigt__p_wxMenuBarBase,
45757 _swigt__p_wxSetCursorEvent,
45758 _swigt__p_wxFSFile,
45759 _swigt__p_wxCaret,
45760 _swigt__ptrdiff_t,
45761 _swigt__std__ptrdiff_t,
45762 _swigt__p_wxRegion,
45763 _swigt__p_wxPoint2D,
45764 _swigt__p_int,
45765 _swigt__p_wxSize,
45766 _swigt__p_wxDC,
45767 _swigt__p_wxPySizer,
45768 _swigt__p_wxVisualAttributes,
45769 _swigt__p_wxNotifyEvent,
45770 _swigt__p_wxPyEvent,
45771 _swigt__p_wxPropagationDisabler,
45772 _swigt__p_form_ops_t,
45773 _swigt__p_wxAppTraits,
45774 _swigt__p_wxArrayString,
45775 _swigt__p_wxShowEvent,
45776 _swigt__p_wxToolTip,
45777 _swigt__p_wxMoveEvent,
45778 _swigt__p_wxSizeEvent,
45779 _swigt__p_wxActivateEvent,
45780 _swigt__p_wxIconizeEvent,
45781 _swigt__p_wxMaximizeEvent,
45782 _swigt__p_wxQueryNewPaletteEvent,
45783 _swigt__p_wxWindowCreateEvent,
45784 _swigt__p_wxIdleEvent,
45785 _swigt__p_wxMenuItem,
45786 _swigt__p_wxStaticBox,
45787 _swigt__p_long,
45788 _swigt__p_wxDuplexMode,
45789 _swigt__p_wxTIFFHandler,
45790 _swigt__p_wxXPMHandler,
45791 _swigt__p_wxPNMHandler,
45792 _swigt__p_wxJPEGHandler,
45793 _swigt__p_wxPCXHandler,
45794 _swigt__p_wxGIFHandler,
45795 _swigt__p_wxPNGHandler,
45796 _swigt__p_wxANIHandler,
45797 _swigt__p_wxMemoryFSHandler,
45798 _swigt__p_wxZipFSHandler,
45799 _swigt__p_wxInternetFSHandler,
45800 _swigt__p_wxPyFileSystemHandler,
45801 _swigt__p_wxEvtHandler,
45802 _swigt__p_wxCURHandler,
45803 _swigt__p_wxICOHandler,
45804 _swigt__p_wxBMPHandler,
45805 _swigt__p_wxImageHandler,
45806 _swigt__p_wxFileSystemHandler,
45807 _swigt__p_wxRect,
45808 _swigt__p_wxButton,
45809 _swigt__p_wxGBSpan,
45810 _swigt__p_wxPropagateOnce,
45811 _swigt__p_wxAcceleratorTable,
45812 _swigt__p_wxStdDialogButtonSizer,
45813 _swigt__p_char,
45814 _swigt__p_wxGBPosition,
45815 _swigt__p_wxImage,
45816 _swigt__p_wxFrame,
45817 _swigt__p_wxScrollWinEvent,
45818 _swigt__p_wxPaperSize,
45819 _swigt__p_wxImageHistogram,
45820 _swigt__p_wxPoint,
45821 _swigt__p_wxCursor,
45822 _swigt__p_wxObject,
45823 _swigt__p_wxInputStream,
45824 _swigt__p_wxOutputStream,
45825 _swigt__p_wxPyInputStream,
45826 _swigt__p_wxDateTime,
45827 _swigt__p_wxKeyEvent,
45828 _swigt__p_wxNavigationKeyEvent,
45829 _swigt__p_wxWindowDestroyEvent,
45830 _swigt__p_unsigned_long,
45831 _swigt__p_wxWindow,
45832 _swigt__p_wxMenuBar,
45833 _swigt__p_wxFileSystem,
45834 _swigt__p_wxBitmap,
45835 _swigt__unsigned_int,
45836 _swigt__p_unsigned_int,
45837 _swigt__p_wxMenuEvent,
45838 _swigt__p_wxContextMenuEvent,
45839 _swigt__p_unsigned_char,
45840 _swigt__p_wxEraseEvent,
45841 _swigt__p_wxMouseEvent,
45842 _swigt__p_wxCloseEvent,
45843 _swigt__p_wxPyApp,
45844 _swigt__p_wxCommandEvent,
45845 _swigt__p_wxPyCommandEvent,
45846 _swigt__p_wxPyDropTarget,
45847 _swigt__p_wxQuantize,
45848 _swigt__p_wxChildFocusEvent,
45849 _swigt__p_wxFocusEvent,
45850 _swigt__p_wxDropFilesEvent,
45851 _swigt__p_wxControlWithItems,
45852 _swigt__p_wxColour,
45853 _swigt__p_wxValidator,
45854 _swigt__p_wxPyValidator,
45855 0
45856 };
45857
45858
45859 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
45860
45861 static swig_const_info swig_const_table[] = {
45862 {0, 0, 0, 0.0, 0, 0}};
45863
45864 #ifdef __cplusplus
45865 }
45866 #endif
45867
45868
45869 #ifdef __cplusplus
45870 extern "C" {
45871 #endif
45872
45873 /* Python-specific SWIG API */
45874 #define SWIG_newvarlink() SWIG_Python_newvarlink()
45875 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
45876 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
45877
45878 /* -----------------------------------------------------------------------------
45879 * global variable support code.
45880 * ----------------------------------------------------------------------------- */
45881
45882 typedef struct swig_globalvar {
45883 char *name; /* Name of global variable */
45884 PyObject *(*get_attr)(); /* Return the current value */
45885 int (*set_attr)(PyObject *); /* Set the value */
45886 struct swig_globalvar *next;
45887 } swig_globalvar;
45888
45889 typedef struct swig_varlinkobject {
45890 PyObject_HEAD
45891 swig_globalvar *vars;
45892 } swig_varlinkobject;
45893
45894 static PyObject *
45895 swig_varlink_repr(swig_varlinkobject *v) {
45896 v = v;
45897 return PyString_FromString("<Swig global variables>");
45898 }
45899
45900 static int
45901 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
45902 swig_globalvar *var;
45903 flags = flags;
45904 fprintf(fp,"Swig global variables { ");
45905 for (var = v->vars; var; var=var->next) {
45906 fprintf(fp,"%s", var->name);
45907 if (var->next) fprintf(fp,", ");
45908 }
45909 fprintf(fp," }\n");
45910 return 0;
45911 }
45912
45913 static PyObject *
45914 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
45915 swig_globalvar *var = v->vars;
45916 while (var) {
45917 if (strcmp(var->name,n) == 0) {
45918 return (*var->get_attr)();
45919 }
45920 var = var->next;
45921 }
45922 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45923 return NULL;
45924 }
45925
45926 static int
45927 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
45928 swig_globalvar *var = v->vars;
45929 while (var) {
45930 if (strcmp(var->name,n) == 0) {
45931 return (*var->set_attr)(p);
45932 }
45933 var = var->next;
45934 }
45935 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45936 return 1;
45937 }
45938
45939 static PyTypeObject varlinktype = {
45940 PyObject_HEAD_INIT(0)
45941 0, /* Number of items in variable part (ob_size) */
45942 (char *)"swigvarlink", /* Type name (tp_name) */
45943 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
45944 0, /* Itemsize (tp_itemsize) */
45945 0, /* Deallocator (tp_dealloc) */
45946 (printfunc) swig_varlink_print, /* Print (tp_print) */
45947 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
45948 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
45949 0, /* tp_compare */
45950 (reprfunc) swig_varlink_repr, /* tp_repr */
45951 0, /* tp_as_number */
45952 0, /* tp_as_sequence */
45953 0, /* tp_as_mapping */
45954 0, /* tp_hash */
45955 0, /* tp_call */
45956 0, /* tp_str */
45957 0, /* tp_getattro */
45958 0, /* tp_setattro */
45959 0, /* tp_as_buffer */
45960 0, /* tp_flags */
45961 0, /* tp_doc */
45962 #if PY_VERSION_HEX >= 0x02000000
45963 0, /* tp_traverse */
45964 0, /* tp_clear */
45965 #endif
45966 #if PY_VERSION_HEX >= 0x02010000
45967 0, /* tp_richcompare */
45968 0, /* tp_weaklistoffset */
45969 #endif
45970 #if PY_VERSION_HEX >= 0x02020000
45971 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
45972 #endif
45973 #if PY_VERSION_HEX >= 0x02030000
45974 0, /* tp_del */
45975 #endif
45976 #ifdef COUNT_ALLOCS
45977 0,0,0,0 /* tp_alloc -> tp_next */
45978 #endif
45979 };
45980
45981 /* Create a variable linking object for use later */
45982 static PyObject *
45983 SWIG_Python_newvarlink(void) {
45984 swig_varlinkobject *result = 0;
45985 result = PyMem_NEW(swig_varlinkobject,1);
45986 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
45987 result->ob_type = &varlinktype;
45988 result->vars = 0;
45989 result->ob_refcnt = 0;
45990 Py_XINCREF((PyObject *) result);
45991 return ((PyObject*) result);
45992 }
45993
45994 static void
45995 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
45996 swig_varlinkobject *v;
45997 swig_globalvar *gv;
45998 v= (swig_varlinkobject *) p;
45999 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46000 gv->name = (char *) malloc(strlen(name)+1);
46001 strcpy(gv->name,name);
46002 gv->get_attr = get_attr;
46003 gv->set_attr = set_attr;
46004 gv->next = v->vars;
46005 v->vars = gv;
46006 }
46007
46008 /* -----------------------------------------------------------------------------
46009 * constants/methods manipulation
46010 * ----------------------------------------------------------------------------- */
46011
46012 /* Install Constants */
46013 static void
46014 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46015 PyObject *obj = 0;
46016 size_t i;
46017 for (i = 0; constants[i].type; i++) {
46018 switch(constants[i].type) {
46019 case SWIG_PY_INT:
46020 obj = PyInt_FromLong(constants[i].lvalue);
46021 break;
46022 case SWIG_PY_FLOAT:
46023 obj = PyFloat_FromDouble(constants[i].dvalue);
46024 break;
46025 case SWIG_PY_STRING:
46026 if (constants[i].pvalue) {
46027 obj = PyString_FromString((char *) constants[i].pvalue);
46028 } else {
46029 Py_INCREF(Py_None);
46030 obj = Py_None;
46031 }
46032 break;
46033 case SWIG_PY_POINTER:
46034 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46035 break;
46036 case SWIG_PY_BINARY:
46037 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46038 break;
46039 default:
46040 obj = 0;
46041 break;
46042 }
46043 if (obj) {
46044 PyDict_SetItemString(d,constants[i].name,obj);
46045 Py_DECREF(obj);
46046 }
46047 }
46048 }
46049
46050 /* -----------------------------------------------------------------------------*/
46051 /* Fix SwigMethods to carry the callback ptrs when needed */
46052 /* -----------------------------------------------------------------------------*/
46053
46054 static void
46055 SWIG_Python_FixMethods(PyMethodDef *methods,
46056 swig_const_info *const_table,
46057 swig_type_info **types,
46058 swig_type_info **types_initial) {
46059 size_t i;
46060 for (i = 0; methods[i].ml_name; ++i) {
46061 char *c = methods[i].ml_doc;
46062 if (c && (c = strstr(c, "swig_ptr: "))) {
46063 int j;
46064 swig_const_info *ci = 0;
46065 char *name = c + 10;
46066 for (j = 0; const_table[j].type; j++) {
46067 if (strncmp(const_table[j].name, name,
46068 strlen(const_table[j].name)) == 0) {
46069 ci = &(const_table[j]);
46070 break;
46071 }
46072 }
46073 if (ci) {
46074 size_t shift = (ci->ptype) - types;
46075 swig_type_info *ty = types_initial[shift];
46076 size_t ldoc = (c - methods[i].ml_doc);
46077 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46078 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46079 char *buff = ndoc;
46080 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46081 strncpy(buff, methods[i].ml_doc, ldoc);
46082 buff += ldoc;
46083 strncpy(buff, "swig_ptr: ", 10);
46084 buff += 10;
46085 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46086 methods[i].ml_doc = ndoc;
46087 }
46088 }
46089 }
46090 }
46091
46092 /* -----------------------------------------------------------------------------*
46093 * Initialize type list
46094 * -----------------------------------------------------------------------------*/
46095
46096 #if PY_MAJOR_VERSION < 2
46097 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46098 is copied out of Python/modsupport.c in python version 2.3.4 */
46099 static int
46100 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46101 {
46102 PyObject *dict;
46103 if (!PyModule_Check(m)) {
46104 PyErr_SetString(PyExc_TypeError,
46105 "PyModule_AddObject() needs module as first arg");
46106 return -1;
46107 }
46108 if (!o) {
46109 PyErr_SetString(PyExc_TypeError,
46110 "PyModule_AddObject() needs non-NULL value");
46111 return -1;
46112 }
46113
46114 dict = PyModule_GetDict(m);
46115 if (dict == NULL) {
46116 /* Internal error -- modules must have a dict! */
46117 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46118 PyModule_GetName(m));
46119 return -1;
46120 }
46121 if (PyDict_SetItemString(dict, name, o))
46122 return -1;
46123 Py_DECREF(o);
46124 return 0;
46125 }
46126 #endif
46127
46128 static swig_type_info **
46129 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46130 static PyMethodDef swig_empty_runtime_method_table[] = {
46131 {
46132 NULL, NULL, 0, NULL
46133 }
46134 };/* Sentinel */
46135
46136 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46137 swig_empty_runtime_method_table);
46138 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46139 if (pointer && module) {
46140 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46141 }
46142 return type_list_handle;
46143 }
46144
46145 static swig_type_info **
46146 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46147 swig_type_info **type_pointer;
46148
46149 /* first check if module already created */
46150 type_pointer = SWIG_Python_GetTypeListHandle();
46151 if (type_pointer) {
46152 return type_pointer;
46153 } else {
46154 /* create a new module and variable */
46155 return SWIG_Python_SetTypeListHandle(type_list_handle);
46156 }
46157 }
46158
46159 #ifdef __cplusplus
46160 }
46161 #endif
46162
46163 /* -----------------------------------------------------------------------------*
46164 * Partial Init method
46165 * -----------------------------------------------------------------------------*/
46166
46167 #ifdef SWIG_LINK_RUNTIME
46168 #ifdef __cplusplus
46169 extern "C"
46170 #endif
46171 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46172 #endif
46173
46174 #ifdef __cplusplus
46175 extern "C"
46176 #endif
46177 SWIGEXPORT(void) SWIG_init(void) {
46178 static PyObject *SWIG_globals = 0;
46179 static int typeinit = 0;
46180 PyObject *m, *d;
46181 int i;
46182 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46183
46184 /* Fix SwigMethods to carry the callback ptrs when needed */
46185 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46186
46187 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46188 d = PyModule_GetDict(m);
46189
46190 if (!typeinit) {
46191 #ifdef SWIG_LINK_RUNTIME
46192 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46193 #else
46194 # ifndef SWIG_STATIC_RUNTIME
46195 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46196 # endif
46197 #endif
46198 for (i = 0; swig_types_initial[i]; i++) {
46199 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46200 }
46201 typeinit = 1;
46202 }
46203 SWIG_InstallConstants(d,swig_const_table);
46204
46205
46206 #ifndef wxPyUSE_EXPORT
46207 // Make our API structure a CObject so other modules can import it
46208 // from this module.
46209 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46210 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46211 Py_XDECREF(cobj);
46212 #endif
46213
46214 {
46215 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46216 }
46217 {
46218 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46219 }
46220 {
46221 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46222 }
46223 {
46224 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46225 }
46226 {
46227 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46228 }
46229 {
46230 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46231 }
46232 {
46233 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46234 }
46235 {
46236 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46237 }
46238 {
46239 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46240 }
46241 {
46242 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46243 }
46244 {
46245 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46246 }
46247 {
46248 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46249 }
46250 {
46251 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46252 }
46253 {
46254 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46255 }
46256 {
46257 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46258 }
46259 {
46260 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46261 }
46262 {
46263 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46264 }
46265 {
46266 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46267 }
46268 {
46269 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46270 }
46271 {
46272 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46273 }
46274 {
46275 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46276 }
46277 {
46278 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46279 }
46280 {
46281 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46282 }
46283 {
46284 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46285 }
46286 {
46287 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46288 }
46289 {
46290 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46291 }
46292 {
46293 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46294 }
46295 {
46296 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46297 }
46298 {
46299 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46300 }
46301 {
46302 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46303 }
46304 {
46305 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46306 }
46307 {
46308 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46309 }
46310 {
46311 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46312 }
46313 {
46314 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46315 }
46316 {
46317 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46318 }
46319 {
46320 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46321 }
46322 {
46323 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46324 }
46325 {
46326 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46327 }
46328 {
46329 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46330 }
46331 {
46332 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46333 }
46334 {
46335 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46336 }
46337 {
46338 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46339 }
46340 {
46341 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46342 }
46343 {
46344 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46345 }
46346 {
46347 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46348 }
46349 {
46350 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46351 }
46352 {
46353 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46354 }
46355 {
46356 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46357 }
46358 {
46359 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
46360 }
46361 {
46362 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46363 }
46364 {
46365 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46366 }
46367 {
46368 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46369 }
46370 {
46371 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46372 }
46373 {
46374 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
46375 }
46376 {
46377 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46378 }
46379 {
46380 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46381 }
46382 {
46383 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46384 }
46385 {
46386 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46387 }
46388 {
46389 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46390 }
46391 {
46392 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46393 }
46394 {
46395 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46396 }
46397 {
46398 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46399 }
46400 {
46401 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46402 }
46403 {
46404 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46405 }
46406 {
46407 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46408 }
46409 {
46410 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46411 }
46412 {
46413 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46414 }
46415 {
46416 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46417 }
46418 {
46419 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46420 }
46421 {
46422 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46423 }
46424 {
46425 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46426 }
46427 {
46428 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46429 }
46430 {
46431 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46432 }
46433 {
46434 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46435 }
46436 {
46437 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46438 }
46439 {
46440 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46441 }
46442 {
46443 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46444 }
46445 {
46446 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46447 }
46448 {
46449 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46450 }
46451 {
46452 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46453 }
46454 {
46455 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46456 }
46457 {
46458 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46459 }
46460 {
46461 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46462 }
46463 {
46464 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46465 }
46466 {
46467 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46468 }
46469 {
46470 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46471 }
46472 {
46473 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46474 }
46475 {
46476 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46477 }
46478 {
46479 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46480 }
46481 {
46482 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46483 }
46484 {
46485 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46486 }
46487 {
46488 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46489 }
46490 {
46491 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46492 }
46493 {
46494 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46495 }
46496 {
46497 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46498 }
46499 {
46500 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46501 }
46502 {
46503 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46504 }
46505 {
46506 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46507 }
46508 {
46509 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46510 }
46511 {
46512 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46513 }
46514 {
46515 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46516 }
46517 {
46518 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46519 }
46520 {
46521 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46522 }
46523 {
46524 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46525 }
46526 {
46527 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46528 }
46529 {
46530 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46531 }
46532 {
46533 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46534 }
46535 {
46536 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46537 }
46538 {
46539 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46540 }
46541 {
46542 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46543 }
46544 {
46545 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46546 }
46547 {
46548 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46549 }
46550 {
46551 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46552 }
46553 {
46554 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46555 }
46556 {
46557 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46558 }
46559 {
46560 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46561 }
46562 {
46563 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46564 }
46565 {
46566 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46567 }
46568 {
46569 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46570 }
46571 {
46572 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46573 }
46574 {
46575 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46576 }
46577 {
46578 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46579 }
46580 {
46581 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46582 }
46583 {
46584 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46585 }
46586 {
46587 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46588 }
46589 {
46590 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46591 }
46592 {
46593 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46594 }
46595 {
46596 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46597 }
46598 {
46599 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46600 }
46601 {
46602 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46603 }
46604 {
46605 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46606 }
46607 {
46608 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46609 }
46610 {
46611 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46612 }
46613 {
46614 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46615 }
46616 {
46617 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46618 }
46619 {
46620 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46621 }
46622 {
46623 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46624 }
46625 {
46626 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46627 }
46628 {
46629 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46630 }
46631 {
46632 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46633 }
46634 {
46635 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46636 }
46637 {
46638 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46639 }
46640 {
46641 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46642 }
46643 {
46644 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46645 }
46646 {
46647 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46648 }
46649 {
46650 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46651 }
46652 {
46653 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46654 }
46655 {
46656 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46657 }
46658 {
46659 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46660 }
46661 {
46662 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46663 }
46664 {
46665 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46666 }
46667 {
46668 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46669 }
46670 {
46671 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46672 }
46673 {
46674 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46675 }
46676 {
46677 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46678 }
46679 {
46680 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46681 }
46682 {
46683 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46684 }
46685 {
46686 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46687 }
46688 {
46689 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46690 }
46691 {
46692 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46693 }
46694 {
46695 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46696 }
46697 {
46698 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46699 }
46700 {
46701 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46702 }
46703 {
46704 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46705 }
46706 {
46707 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46708 }
46709 {
46710 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46711 }
46712 {
46713 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46714 }
46715 {
46716 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46717 }
46718 {
46719 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46720 }
46721 {
46722 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46723 }
46724 {
46725 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46726 }
46727 {
46728 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46729 }
46730 {
46731 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46732 }
46733 {
46734 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46735 }
46736 {
46737 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46738 }
46739 {
46740 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46741 }
46742 {
46743 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46744 }
46745 {
46746 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46747 }
46748 {
46749 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46750 }
46751 {
46752 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46753 }
46754 {
46755 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46756 }
46757 {
46758 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46759 }
46760 {
46761 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46762 }
46763 {
46764 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46765 }
46766 {
46767 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46768 }
46769 {
46770 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46771 }
46772 {
46773 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46774 }
46775 {
46776 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46777 }
46778 {
46779 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46780 }
46781 {
46782 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46783 }
46784 {
46785 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46786 }
46787 {
46788 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46789 }
46790 {
46791 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46792 }
46793 {
46794 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
46795 }
46796 {
46797 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
46798 }
46799 {
46800 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
46801 }
46802 {
46803 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
46804 }
46805 {
46806 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
46807 }
46808 {
46809 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
46810 }
46811 {
46812 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
46813 }
46814 {
46815 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
46816 }
46817 {
46818 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
46819 }
46820 {
46821 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
46822 }
46823 {
46824 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
46825 }
46826 {
46827 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
46828 }
46829 {
46830 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
46831 }
46832 {
46833 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
46834 }
46835 {
46836 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
46837 }
46838 {
46839 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
46840 }
46841 {
46842 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
46843 }
46844 {
46845 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
46846 }
46847 {
46848 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
46849 }
46850 {
46851 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
46852 }
46853 {
46854 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
46855 }
46856 {
46857 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
46858 }
46859 {
46860 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
46861 }
46862 {
46863 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
46864 }
46865 {
46866 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
46867 }
46868 {
46869 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
46870 }
46871 {
46872 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
46873 }
46874 {
46875 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
46876 }
46877 {
46878 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
46879 }
46880 {
46881 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
46882 }
46883 {
46884 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
46885 }
46886 {
46887 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
46888 }
46889 {
46890 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
46891 }
46892 {
46893 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
46894 }
46895 {
46896 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
46897 }
46898 {
46899 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
46900 }
46901 {
46902 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
46903 }
46904 {
46905 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
46906 }
46907 {
46908 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
46909 }
46910 {
46911 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
46912 }
46913 {
46914 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
46915 }
46916 {
46917 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
46918 }
46919 {
46920 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
46921 }
46922 {
46923 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
46924 }
46925 {
46926 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
46927 }
46928 {
46929 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
46930 }
46931 {
46932 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
46933 }
46934 {
46935 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
46936 }
46937 {
46938 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
46939 }
46940 {
46941 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
46942 }
46943 {
46944 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
46945 }
46946 {
46947 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
46948 }
46949 {
46950 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
46951 }
46952 {
46953 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
46954 }
46955 {
46956 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
46957 }
46958 {
46959 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
46960 }
46961 {
46962 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
46963 }
46964 {
46965 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
46966 }
46967 {
46968 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
46969 }
46970 {
46971 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
46972 }
46973 {
46974 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
46975 }
46976 {
46977 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
46978 }
46979 {
46980 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
46981 }
46982 {
46983 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
46984 }
46985 {
46986 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
46987 }
46988 {
46989 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
46990 }
46991 {
46992 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
46993 }
46994 {
46995 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
46996 }
46997 {
46998 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
46999 }
47000 {
47001 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47002 }
47003 {
47004 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47005 }
47006 {
47007 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47008 }
47009 {
47010 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47011 }
47012 {
47013 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47014 }
47015 {
47016 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47017 }
47018 {
47019 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47020 }
47021 {
47022 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47023 }
47024 {
47025 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47026 }
47027 {
47028 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47029 }
47030 {
47031 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47032 }
47033 {
47034 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47035 }
47036 {
47037 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47038 }
47039 {
47040 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47041 }
47042 {
47043 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47044 }
47045 {
47046 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47047 }
47048 {
47049 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47050 }
47051 {
47052 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47053 }
47054 {
47055 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47056 }
47057 {
47058 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47059 }
47060 {
47061 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47062 }
47063 {
47064 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47065 }
47066 {
47067 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47068 }
47069 {
47070 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47071 }
47072 {
47073 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47074 }
47075 {
47076 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47077 }
47078 {
47079 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47080 }
47081 {
47082 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47083 }
47084 {
47085 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47086 }
47087 {
47088 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47089 }
47090 {
47091 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47092 }
47093 {
47094 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47095 }
47096 {
47097 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47098 }
47099 {
47100 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47101 }
47102 {
47103 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47104 }
47105 {
47106 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47107 }
47108 {
47109 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47110 }
47111 {
47112 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47113 }
47114 {
47115 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47116 }
47117 {
47118 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47119 }
47120 {
47121 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47122 }
47123 {
47124 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47125 }
47126 {
47127 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47128 }
47129 {
47130 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47131 }
47132 {
47133 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47134 }
47135 {
47136 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47137 }
47138 {
47139 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47140 }
47141 {
47142 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47143 }
47144 {
47145 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47146 }
47147 {
47148 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47149 }
47150 {
47151 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47152 }
47153 {
47154 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47155 }
47156 {
47157 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47158 }
47159 {
47160 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47161 }
47162 {
47163 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47164 }
47165 {
47166 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47167 }
47168 {
47169 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47170 }
47171 {
47172 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47173 }
47174 {
47175 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47176 }
47177 {
47178 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47179 }
47180 {
47181 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47182 }
47183 {
47184 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47185 }
47186 {
47187 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47188 }
47189 {
47190 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47191 }
47192 {
47193 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47194 }
47195 {
47196 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47197 }
47198 {
47199 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47200 }
47201 {
47202 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47203 }
47204 {
47205 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47206 }
47207 {
47208 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47209 }
47210 {
47211 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47212 }
47213 {
47214 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47215 }
47216 {
47217 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47218 }
47219 {
47220 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47221 }
47222 {
47223 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47224 }
47225 {
47226 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47227 }
47228 {
47229 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47230 }
47231 {
47232 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47233 }
47234 {
47235 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47236 }
47237 {
47238 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47239 }
47240 {
47241 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47242 }
47243 {
47244 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47245 }
47246 {
47247 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47248 }
47249 {
47250 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47251 }
47252 {
47253 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
47818 }
47819 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
47820 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
47821 {
47822 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
47973 }
47974 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
47975 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
47976 {
47977 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
47984 }
47985
47986 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
47987
47988
47989 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
47990
47991 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
47992 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
47993 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
47994 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
47995 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
47996 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
47997 {
47998 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48041 }
48042 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48043 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48044 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48045 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48046 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48047 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48048 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48049 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48050 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48051 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48052 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48053 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48054 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48055 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48056 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48057 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48058 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48059 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48060 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48061 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48062 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48063 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48064 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48065 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48066 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48067 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48068 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48069 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48070 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48071 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48072 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48073 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48074 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48075 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48076 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48077 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48078 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48079 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48080 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48081 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48082 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48083 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48084 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48085 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48086 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48087 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48088 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48089 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48090 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48091 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48092 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48093 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48094 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48095 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48096 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48097 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48098 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48099 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48100 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48101 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48102 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48103 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48104 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48105 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48106 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48107 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48108 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48109 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48110 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48111 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48112 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48113 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48114 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48115 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48116 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48117 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48118 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48119 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48120 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48121 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48122 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48123 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48124 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48125 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48126 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48127 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48128 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48129 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48130 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48131 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48132 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48133 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48134 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48135 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48136 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48137 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48138 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48139 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48140 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48141 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48142 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48143 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48144 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48145 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48146 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48147 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48148 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48149 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48150 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48151 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48152 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48153 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48154 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48155 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48156 {
48157 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48209 }
48210 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48211 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48212 {
48213 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48226 }
48227 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48228 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48229 {
48230 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48237 }
48238 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48239 {
48240 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48295 }
48296
48297 // Initialize threading, some globals and such
48298 __wxPyPreStart(d);
48299
48300
48301 // Although these are defined in __version__ they need to be here too so
48302 // that an assert can be done to ensure that the wxPython and the wxWindows
48303 // versions match.
48304 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48305 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48306 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48307
48308 }
48309
wxWidgets (Impactor)